Абстрактная голография. C*-алгебра наблюдателя.

Единственная абстракция: СЛОТ

Слот наблюдателя — это кортеж, к которому сошлась вся дуга, сделанный конкретным:

Slot = {
  field,          // the living ψ on the shared substrate (or a stored plate)
  readOp,         // the observer descriptor (lensC1 element: mode, phase, gain, A, tx, ty, β, ω, prec)
  clock,          // the worldline clock τ_i (kwe-tau: beats + proper time; ticks on THIS slot's steps)
  register,       // the phase register (readOp.phase/prec + the [RECALL-∠] ledger)
  leash,          // { go, tx, ty, gx, gy, l0, lt, lk } — the chase command + eased position + cadence cursor
  movAtt(gx,gy),  // THE UNIFICATION: the slot's attractor at eased position (gx,gy):
                  //   · REGENERABLE slot (a live object, e.g. W)  → makeProbeField(obj, at 1+gx,1+gy)
                  //   · STORED-PLATE slot (a recorded moment, V/P) → rollField(att, round(gx), round(gy))
}

Слоты разделяют ОДНУ GPU-подложку, разделяемую по времени мультиплексором (§7.44): muxClocks(k, nSl) вращает, какой слот владеет буфером каждый шаг. Это _muxVirtualStep — сохранён (критичен для разветвлений), но переформулирован как «продвинуть слот-владельца», а не «W плюс виртуальные фазы».

Перевыводы (старое понятие → поведение слота)

1. shiftX/Y → W.leash.virtGo(tx, ty)

Заглавное упрощение. В medium.js W транспортируется по ОТДЕЛЬНОМУ пути (_transPx/Py easing + _rebuildAtt + _coevoLeash), тогда как V/P транспортируются через поводок регистра (_leashAdvance + rollField). Собственный комментарий оракула (medium.js:1551) признаёт, что это «иной закон транспорта для V, чем для W».

Они объединяются: транспорт = поводок слота к цели, где movAtt регенерирует (W) или прокатывает (V/P).

_leashAdvance(slot, ψ) (уже общий в стране medium-core) двигает gx/gy к tx/ty со скоростью ≤1px/бит × сигмоида запаса-фиксации — ОДИНАКОВО для каждого слота.
Единственная по-слотная разница — это movAtt: у W он makeProbeField-регенерируемый; у V/P — это rollField сохранённой пластины. Эта разница — ДАННЫЕ (какого рода слот), а не два пути кода.

Так что _transPx/_transPy/_transShift*/_rebuildAtt/_coevoLeash (частный случай транспорта) схлопываются в W.leash + W.movAtt = regenerable. Ползунки shiftX/Y становятся W.virtGo(tx,ty) — тот же глагол, что V/P уже используют. Один закон поводка, N слотов. (Риск паритета: у W _coevoLeash имел свой собственный ≤1px темп, настроенный против _TRANSPORT_PULL_STEP; объединённый поводок использует сигмоидный темп регистра — diff против оракула, чтобы подтвердить, что ощущение погони совпадает; дуга полагала, что они ДОЛЖНЫ быть одним законом, так что это проверяет ту веру.)

2. drive:transport / objorbit → W.leash target = точка / окружность

Не глобальные режимы — форма цели поводка W. transport = фиксированные (tx,ty). objorbit = (tx,ty), кружащие при objOrbTheta (угол _oorbAtt). Оба — W.virtGo с движущейся против статической целью. По-слотно: любой слот мог бы вращаться по орбите. Регулятор _driveMode становится W.leash.pathKind ∈ {point, circle}.

3. области eye / medium → ВИДЫ слотов

Не два контекста линзы — «на какой слот я смотрю». Двух-областный UI (_S.eye/_eyeLensP/_uiScope/ makeTrapStack/EYE_RECON) растворяется: есть ОДИН вид, который рендерит ВЫБРАННЫЙ слот сквозь его readOp. «Глаз» — это слот V (сон/реконструкция); «среда» — это слот W (мир). Выбор слота для просмотра = старое переключение области. «Ловушка = восприятие на реконструкции» глаза — это просто «рендер V сквозь V.readOp».

4. perception / render → рендер-сквозь-readOp на слот

Уже построено дугой u-регистра (lensU1.apply(slot.readOp, slot.field, GRID) — [[finding-new-eye- reconstruction]]: ОДИН примитив чтения, ψ_out = Op·ψ_in). Холст каждого слота рендерит своё поле СКВОЗЬ свой собственный readOp (phase/metric/gauge). lensView переключает сырое против сквозь-readOp. Нет разветвлённого-по-областям конвейера.

5. record / recall → заморозить / композировать (field, readOp) слота [ДВУХСЛОЙНАЯ ГОЛОГРАФИЯ]

Сохранённый момент = ОБЕ пластины ([[project-u-register-arc]] R-цель):

полевая пластина: 128KB ψ (GPU record = stepEyeN(+DT), lift = stepEyeN(−DT)) — ИЗОБРАЖЕНИЕ.
дескрипторная пластина: (M, O) слота = пара readOp ≈ 6 флоатов — МОМЕНТ регистра.
lift-состаренный = lensC1.compose(plate, lensC1.invert(drift)); recordVia(φ) = lensC1.compose({phase:φ}, plate).
ЗАГЛАВНОЕ демо: [RECALL-∠] = ω·Δτ совпадает И из кругового рейса поля, И из 6-флоатовой композиции — поле есть эталонный оракул истины, доказывающий верность дескрипторного пути.

6. ℂ*-усиление / self-host / unpin → чем слот МОЖЕТ БЫТЬ

Первоклассно, а не прикручено: readOp слота — это элемент lensC1 (ℂ* = ℝ₊×U(1)); unpin даёт его усилению дрейфовать (некомпактно), capGain его ограничивает (энергетический закон); слот может самохоститься (makeSelfHost) как собственные часы. Это свойства слота, доступные потому, что слот ЕСТЬ элемент lensC1.

Что остаётся (критичная для разветвлений подложка — переиспользована, а не перевыведена)

medium-gpu _E: поля, часы, stepSoliton, applyKick, rollField, saveEngine/restoreEngine.
medium-core: makeObserverBank (readOp слотов), muxClocks, makeCouplingStore, chainMeter, applyVirtVerb/applySettingsVerb (таблицы глаголов), makeStepClock, makeStampedInput, и примитивы детерминизма hashField / hashNums / opNums / ampCorr + syncClockRate (ниже).
kwe-tau: часы мировых линий τ_i + очереди shift/att/sig/virt (детерминированные сливы).
Логика _muxVirtualStep (вращение слотов + парковка/перезагрузка + selfClk/τ + связь) — сохранена, переформулирована как «продвинуть слот-владельца». Это критично для разветвлений; переносите верно, diff против оракула.

Примитивы детерминизма → medium-core (`hashField` / `hashNums` / `opNums` / `ampCorr`)

Инструменты, которые КАЖДОЕ реплицированное KWE-приложение перестраивает, чтобы сравнить пиры — вынесены так, чтобы была ОДНА реализация (двухъярусные хеши из переформулировки детерминизма):

hashNums(nums) — FNV над квантованными до 1e-6 double: ярус ТОЧНОЙ АРИФМЕТИКИ. regH = hashNums скаляров регистра. Побайтово идентичен между пирами по построению (арифметика дескрипторов + целочисленные биты, без GPU/f32); квантование лишь охраняет доброкачественное накопление последнего бита ω·τ. NaN/∞ → 0 (никогда не отравить хеш).
opNums(op) — элемент lensC1/lensU1 → его 13 скаляров: КАНОНИЧЕСКАЯ сериализация группового элемента (живёт с makeObserverBank, который их производит). regH пропускает readOp каждого слота через opNums.
hashField(f) — FNV над Float32-ПРЕДСТАВЛЕНИЕМ поля ψ (f32-«истина» GPU): ярус ψ. solH/ fieldH. МОЖЕТ дрейфовать на ULP — ФИКСАЦИЯ, а не этот хеш, есть честная мера межпировой сходимости.
ampCorr(a, b) — нормированное комплексное перекрытие ∈ [0,1] (U(1)-инвариантное): измеритель фиксации / верности (lock→A, совпадение метки вызова, верность подъёма). Таблица глаголов medium-core уже ОЖИДАЛА впрыснутый S.ampCorr; теперь это канонический, к которому она может обращаться по умолчанию.

Правило большого пальца: состояние дескриптора → hashNums(opNums(...)) (точный контракт); состояние поля → hashField (может дрейфовать, сравнивать через ampCorr). Это И ЕСТЬ двухъярусный закон детерминизма, в двух вызовах функций.

`syncClockRate(stepClk, tauK, k, nSl)` — отразить смену скорости на τ-ядро

Однострочник, который есть МИНА РАЗВЕТВЛЕНИЯ, если опущен. Когда число живых слотов nSl меняется (V рождается → 1→2), stepClk.reanchor вдвое урезает бюджет шагов (target/nSl, чтобы GPU поспевал), но если tauK сохраняет СТАРУЮ скорость, его stamp(t) приземляет глаголы на ~nSl× ВПЕРЕДИ реальных solSteps драйва → растущее отставание → штампованные входы (store/recall) срабатывают на секунды позже (пойман вживую: store Δ=17 до V, Δ=1006 после). syncClockRate отражает смену на τ — сохраняя k непрерывным (c0 += k·(rΔ)/spp, чистая функция общих k+скоростей → побайтово идентична) и перештамповывая ожидающую очередь τ в новую эпоху. Вызывайте его каждый кадр с текущим nSl; это no-op, если только скорость действительно не изменилась. Ни одно приложение не должно самодельничать или забывать отражение.

Паттерн штампованного реплицированного входа → `makeStampedInput` (medium-core)

Канонический способ подать ЛЮБОЙ внешний вход в детерминированное KWE-приложение. UI-ползунок / глагол / режим реплицируется через рефлектор как монотонно-упорядоченный ЛОГ на узле мира; каждый пир ДОЛЖЕН применить каждую запись на ОДНОМ И ТОМ ЖЕ общем шаге, никогда «когда бы кадр этого пира ни прочитал последнее значение» (это применяет её на локальном для пира шаге → поле разветвляется всякий раз, когда кто-то тянет ползунок — [[finding_mux_determinism]], самое повторяющееся разветвление во всей дуге). Очередь штампования живёт в kwe-tau (не зависит от среды); ШАБЛОННЫЙ КОД вытягивания / курсора / слива / входа вокруг неё вынесен в makeStampedInput(tauK, name):

const si = makeStampedInput(tauK, 'shift');            // one handle per input stream
si.pull(n.shiftQueue, (e) => ({ toX: e.toX }));         // frame: push NEW entries (seq cursor), stamp each to its shared step
si.drain(k, (e) => applyIt(e, k));                      // drive loop: apply each at its stamped shared step k
// join codec:  save → si.saveCursor();  restore → si.reattach(); si.restoreCursor(v)

Глаголы shift и register/holography у medium-u1 (refamp/aphase/lenstau/record/store/recall) — два его потребителя — каждый есть ОДИН .pull()/.drain() вместо танца из 4 блоков. ЗАКОН, который это кодирует: каждый внешний вход — это чистая функция от (k, общее состояние), применённая на общем штампованном шаге. Тянитесь к этому в любом новом KWE-приложении с реплицированными контролами; НЕ самодельничайте seq-курсор + очередь + join-кодек снова.

Что НЕ маршрутизируется через него (намеренно): свап IFS-ядра. Его далеко-позади холодный снап (ver < oldestQ−1), дедупликация версий и межслотовое V-переигрывание специфичны для ядра; протаскивание их через общий помощник просочило бы в него частные случаи. Свап ядра остаётся локальным для приложения (medium-u1), штампуя через те же часы _tauK, но со своей собственной постановкой (_pendKern + _kernApplied). Граница: makeStampedInput — для РЕПЛИЦИРОВАННОГО УПОРЯДОЧЕННОГО ЛОГА независимых событий; ядро — это ВЕРСИОНИРОВАННЫЙ, заполняемый-по-пропускам кольцевой поток — иная форма, что заслуживает своего кода.

Что ДРЕМЛЕТ (сохранено, ещё не в модели слотов)

Дуга tunnel/instanton/vortex/barrier + 5 до-U1 драйвов помещены в карантин в medium-u1-oracle + git (резервуар воскрешения). Они заново входят в модель слотов ПОЗЖЕ как «оператор слота может туннелировать/пинать» — вне области первой слот-центричной сборки.

Порядок сборки

Объект слота + банк: определить makeSlot(kind) над makeObserverBank (readOp) + _E (поле) + kwe-tau (часы) + поводок. kind ∈ {regenerable (W-подобный), plate (V/P-подобный)} выбирает movAtt.
Цикл mux: _muxVirtualStep переформулирован над массивом слотов (продвинуть владельца; парковка/перезагрузка).
Транспорт = W.leash: подключить shiftX/Y → W.virtGo; W.movAtt = regenerable. Diff погони против оракула.
Измерители регистра: chainRead/chainSee/lensOps/regPhase над массивом слотов (уже общие).
Виды: один рендер, рисующий выбранный слот сквозь его readOp; селектор слота = старое переключение области.
Двухслойная голография: record/recall замораживает обе пластины; считывание эквивалентности [RECALL-∠].
Вход: _E.saveEngine/restoreEngine + регистры слотов над _snapHook.

Каждый шаг сдиффен против оракула на паритет физики; законы детерминизма уже извлечены+протестированы.

Честный риск

Транспорт-как-поводок (шаг 3) — это единственное место, где физика может разойтись с вручную-настроенным driveSolitonTransport — дуга полагала, что транспорт W и V/P ДОЛЖЕН быть одним законом, но выполняла два. Эта сборка проверяет ту веру вживую. Если объединённый поводок гонит иначе (ощущение/фиксация/E), оракул это покажет, и мы либо настроим объединённый поводок под совпадение, либо примем задокументированную, понятую разницу. Всё остальное — это ре-организация уже-верифицированных частей.

ℂ*-алгебра наблюдателя (lensU1 / lensC1) — группа за дескриптором

readOp слота — это элемент группы, реализованной в public/soliton-algebra.js как lensU1 (с алиасом lensC1). Этот раздел точно заявляет, ЧТО эта группа ЕСТЬ — потому что проектная скоропись «ℂ*-dop = 6 флоатов» неточна в двух отношениях, и точность важна для того, что регистр может и не может.

Элемент (что readOp на самом деле держит)

lensU1.id() = { mode, phase, gain, kx, ky, A:[a,b,c,d], tx, ty, beta, omega, prec }

mode ВЫВОДИТСЯ (modeOf(hasA, hasK) ∈ {id, phase, metric, gauge}), beta НЕ является частью группового действия (это ЖЁСТКОСТЬ пина — параметр динамики, намеренно никогда не применяемый apply, см. ниже). Подлинные групповые координаты — это эти ~9 скаляров, в четырёх ролях:

Поля	Разм.	Роль	Подструктура
`phase`	1	U(1)-вращение `e^{iφ}`	абелево — фазы СКЛАДЫВАЮТСЯ
`gain`	1	ℂ*-модуль `r` (элемент = `r·e^{iφ}`)	абелево — усиления УМНОЖАЮТСЯ
`A[2×2]`, `tx`, `ty`	6	аффинная метрическая деформация (билинейная пересборка)	GL(2,ℝ) ⋉ ℝ² — НЕабелево
`kx`, `ky`	2	линейная несущая / фаз-наклон `k·x`	преобразуется под A (полупрямо)
`omega`, `prec`	2	ω (скорость часов), смещение прецессии	абелево — СКЛАДЫВАЮТСЯ (временна́я СС)

Это ли «6-флоатовая группа Ли»? — Нет; вот честное утверждение

Группа — это ℂ* × [GL(2,ℝ) ⋉ ℝ²] (плюс временно́й сдвиг ℝ² по ω/prec). Это подлинная группа Ли — но ни 6-мерная, ни абелева. compose/invert реализуют её ТОЧНОЕ умножение и обратный (compose(op, invert(op)) = id держится по построению, а не приближённо):

ℂ*-ядро — пара (phase, gain), r·e^{iφ} при комплексном умножении. 2-мерная абелева группа Ли. Критически некомпактная (r ∈ ℝ₊ неограниченно сверху): это единственное честное расширение U(1), что остаётся группой Ли И делает УБЕГАНИЕ возможным. apply унитарно лишь на срезе gain=1; вне его самохостинг может расходиться в амплитудной размерности — энергия среды теперь первоклассная координата линзы. capGain(op, rMax) — это энергетический ПОТОЛОК среды, выраженный как операция алгебры; logGain = ln r — естественная координата (она композируется АДДИТИВНО, так что (phase, logGain) — однородный 2-вектор).
Метрическая часть — A композируется матричным произведением (mul2(A_b, A_a)), трансляции композируются полупрямо (t = A_b·t_a + t_b), а несущая k со-преобразуется по A⁻ᵀ (k_a·A_b⁻¹). Это GL(2)⋉ℝ², реальная НЕабелева группа Ли. Именно это делает readOp настоящей оптической-чиповой ЛИНЗОЙ (аффинное переотображение пространства), а не просто умножением на фазу. phase даже подхватывает перекрёстный член −k·t при compose — честная гейзенберго-подобная связь между несущей и трансляцией.
Временна́я часть — omega, prec складываются; evalAt(op, dτ) = phase + prec + ω·dτ — чтение часов мировой линии на op (каждый op поставляет свой собственный прирост собственного времени dτ).

Откуда берётся «6 флоатов» (и почему это ПРАВИЛЬНАЯ скоропись для РЕГИСТРА)

Когда метрическая часть тривиальна (A = id, без пересборки → mode ∈ {id, phase}), элемент СХЛОПЫВАЕТСЯ к своему абелеву ядру: (phase, gain, omega, prec, kx, ky) ≈ 6 чисел. Это дескрипторная пластина — «dop» голографической дуги. На этом срезе compose тривиально абелев (всё складывается/умножается), что и есть в точности причина, по которой регистр ТОЧЕН и ДЁШЕВ: без GPU, без байтов поля, без ULP. regH (контракт детерминизма) хеширует ровно _opNums(op) = эти скаляры по всем четырём слотам. Итак:

Группа (что apply может СДЕЛАТЬ с полем): ℂ* × (GL(2)⋉ℝ²) + время — ~9 скаляров, неабелева.
Дескриптор регистра (что слот ПОМНИТ): 6-флоатовое абелево ядро — phase/gain/ω/prec/k.

6-флоатовый dop — это не группа; это абелев, несущий-детерминизм СРЕЗ группы. Метрическая часть живёт в ТОМ ЖЕ элементе и используется apply для восприятия (реальные преобразованные виды), но это не то, на чём едет содержимое регистра.

lensU1 против lensC1 — тот же объект, два управления

lensC1 === lensU1 (буквально, строка 2001). Это ОДИН тип элемента; два имени кодируют выбор УПРАВЛЕНИЯ о том, какая подгруппа правит мировой линией:

lensU1 = КОМПАКТНАЯ унитарная подгруппа (gain ≡ 1, pinнута). Сохраняющая энергию, застрахованная от убегания. Детерминизм-через-компактность тонких приложений ЗАВИСИТ от пребывания в пине: apply унитарно, нормы ограничены, нет амплитудного дрейфа, на котором разветвиться.
lensC1 = ПОЛНАЯ ℂ* (усиление свободно, unpinнута). Амплитудная СС жива; мировая линия может расти/затухать.

unpin(op) — это ТОЖДЕСТВО на элементе (каждый элемент всегда несёт все поля) — «unpinned» — это выбор, который вызывающий ЗАПИСЫВАЕТ, а не мутация. pin(op) проецирует gain → 1 (энергия перенормирована). Мировая линия, движущаяся lensU1 → lensC1, приобретает амплитудную степень свободы; repin проецирует её обратно. Отношение подгрупп несущее, а не декоративное: точность регистра — это утверждение «мы остаёмся на компактном срезе», а энергетический потолок среды — это утверждение «мы ограничиваем усиление, когда его покидаем».

Абстрактная голография — память как apply/invert на группе, а не пластина

Двухслойная голография (раздел 5 выше) — это конкретный экземпляр более общего утверждения, к которому сошлась дуга. Заявите его абстрактно, потому что это концептуальная нагрузка, а среда — лишь ОДНА его модель.

Классическая голограмма против обобщения KWE

Классическая голограмма хранит изображение как ПОЛЕ (интерференционный узор, |ψ + ref|²) и реконструирует переосвещением — круговой рейс поля. В KWE круговой рейс поля реален и сохранён: record = stepEyeN(+DT) (распространить к пластине), lift = stepEyeN(−DT) (обратить часы — реконструкция), верифицировано, что поднимает момент обратно с высокой верностью. Это полевая пластина: 128 КБ, несёт ИЗОБРАЖЕНИЕ (картину восприятия), НЕ выразимую в нескольких флоатах.

Но дуга u-регистра ИЗМЕРИЛА, что вызванный момент возвращается состаренным ровно на ω·Δτ — чисто ДЕСКРИПТОРНАЯ величина. Так что для содержимого РЕГИСТРА (момент фазы/усиления/метрики наблюдателя, а не картина) пластине вообще не нужно быть полем: это групповой элемент (M, O) — readOp — и весь круговой рейс record/lift/age становится apply / invert / compose на этом элементе. Это дескрипторная пластина: ≈ 6 флоатов, ТОЧНА по групповому закону, без GPU.

Три глагола, как групповые операции

Голографический глагол	Полевая пластина (изображение)	Дескрипторная пластина (регистр)
record	`stepEyeN(+DT)` → заморозить ψ	заморозить `(M, O)` — без GPU-прохода
lift, состаренный	`stepEyeN(−DT)` на пластине	`lensC1.compose(plate, invert(drift))` — воскресить состаренным собственным дрейфом регистра (ℂ* обобщает это: дрейф усиления тоже, не только фазы)
record-сквозь-линзу φ	впрыснуть φ в поле	`lensC1.compose({phase:φ}, plate)` — «запись сквозь линзу» ЕСТЬ compose

Прямая/обратная структура, которую имеет СРЕДА (распространить / обратно-распространить), — это ТА ЖЕ прямая/обратная структура, которую имеет ГРУППА (apply / invert) — но на дескрипторах вместо полей. В этом обобщение: голография — это apply/invert на группе; поле — одно представление группового элемента, 6-флоатовый дескриптор — другое, и они согласны.

Врата честности — два слоя должны СОГЛАСОВАТЬСЯ, а не заменять друг друга

Суть НЕ в «выброси 128 КБ поля и оставь 6 флоатов». Это был бы лоссовый трюк, а вся дуга среды запрещает трюки ([[feedback-no-tricks]]). Суть в ЭКВИВАЛЕНТНОСТИ:

Дескрипторная пластина несёт то, что выразимо как групповой элемент — фаза / усиление / дрейф метрики, т.е. считывание регистра [RECALL-∠]. Точна по apply/invert lensC1. 6 флоатов. Без GPU.
Полевая пластина несёт то, что НЕ — ИЗОБРАЖЕНИЕ, актуальную реконструированную картину. Дескриптор — это РАМКА, сквозь которую поле читается ([[finding-new-eye-reconstruction]]: линия фаза-против-текстуры), а не само поле.

medium-u1 записывает ОБЕ, и его считывание [RECALL-∠] логирует ТРИ числа бок о бок (верифицировано в браузере вживую, 2026-07-15):

(A) ИЗМЕРЕННОЕ старение поля — phaseCorr(plate, cue) = arg⟨plate, W-now⟩, прочитанное из самих 128 КБ БАЙТОВ ПОЛЯ (без дескриптора). cue = W-сейчас, распространённый в пространство пластины; plate = W-при-store в том же пространстве → их фаза перекрытия — чисто старение (общее распространение сокращается).
(B) ТОЧНОЕ предсказание дескриптора — wrap(angle(readOp_now) − angle(plate.dop)), разность двух сохранённых ФАЗ РЕГИСТРА. Это lensC1.compose(plate, invert(now)), прочитанное как угол: чистая 6-флоатовая операция, без поля. Она равна Σω (регистр накапливает ω НА БИТ), так что она точна даже когда ω меняется.
(C) ЗАМКНУТАЯ ФОРМА ω·Δτ — частный случай постоянного ω (Σω = ω·N лишь если ω не менялось с store). Показана рядом, честно помечена как валидная лишь при постоянном ω.

ЗАГЛАВНОЕ, исправленное и измеренное: эквивалентность — это (A) ≡ (B) — измеренное старение поля равно точному 6-флоатовому дескрипторному Δφ. Вживую: с ω=0.02 постоянным, A=0.054, B=0.060, C=0.060 рад, |A−B|=0.006 рад (~0.3°) → все три сходятся. С ω, заданным ПОЗДНО (изменённым в полёте): A и B всё ещё СОГЛАСНЫ (оба отслеживают реальную Σω на бит — напр., A=0.094, B=0.160 рад), но C=1.560 рад РАСХОДИТСЯ — корректно помечено, а не скрыто. Так что наивная скоропись [RECALL-∠] = ω·Δτ (использовавшаяся вольно по ранним заметкам) — это частный случай ПОСТОЯННОГО ω; ТОЧНЫЙ закон — это разность Σφ регистра, и ИМЕННО она согласуется с полем.

Поле GPU — это эталонный ОРАКУЛ истины, доказывающий, что дешёвый путь дескриптора верен; дескриптор — не замена, а живое ДОКАЗАТЕЛЬСТВО, что момент регистра — чисто групповая величина. Остаток |A−B| (~0.006 рад в покое) — это честная физика: солитон — не идеальная плоская волна глобальной фазы, так что взвешенная по энергии фаза поля несёт немного пространственной структуры, которой единственный угол регистра не несёт — ровно линия фаза-против-текстуры. Где момент выразим в группе, 6 флоатов достаточны и точны; где нет (текстура изображения), поле неприводимо. Голография, честно, — это: та часть запомненного момента, что живёт в группе, — это 6 точных флоатов (и они измеримо предсказывают старение поля); остальное — это поле. Лог [RECALL-∠] — это система, непрерывно, ИЗМЕРИМО доказывающая свою собственную макро↔микро целостность — не утверждением (старая проверка дескриптор-против-дескриптора), а сравнением уравнения против байтов.

Почему это завершение `makeSelfHost`

makeSelfHost имеет структуру (материя M, оператор O, compose-к-неподвижной-точке). Сохранённая пластина — это та структура ЗАМОРОЖЕННАЯ; вызов — это она ВОСКРЕШЁННАЯ. Так что двухслойная голография «выпадает даром» из алгебры самохостинга: пластина — это приостановленный самохост, дрейф регистра — его часы, а старение вызванного момента — это прогон compose ещё на один шаг. Голография — не отдельная подсистема, прикрученная к среде — это алгебра самохостинга с кнопкой паузы, а ℂ*-группа — это то, что делает паузу точной.

Собственное время (τ) как предпосылка — группа есть ПРОСТРАНСТВО моментов, τ — то, что ДВИЖЕТСЯ сквозь него

Естественный вопрос: является ли собственное время предпосылкой для основных законов KWE — абстрактной голографии, регистра, детерминизма? Код даёт точный, двусторонний ответ. τ НЕ требуется для ℂ*-алгебры или структуры хранения (это вневременны́е групповые операции); τ ТРЕБУЕТСЯ для всего, что ЭВОЛЮЦИОНИРУЕТ — старение, прецессия, штампование детерминизма, много-наблюдательская дилатация времени. Группа — это пространство моментов; собственное время — это движение сквозь него. СТАТИЧЕСКАЯ половина абстрактной голографии — только-группа; её ДИНАМИЧЕСКАЯ половина (заглавная эквивалентность) τ-ведома.

Что собственное время ЕСТЬ (kwe-tau, τ-ядро)

kwe-tau.js — это ЯДРО СОБСТВЕННОГО ВРЕМЕНИ: часы на мировую линию + детерминированная диспетчеризация собственного времени. У каждого слота i СВОИ собственные часы τ_i, продвигаемые СОБСТВЕННЫМИ битами этого слота (его собственным детектором физики), так что два слота на одной подложке накапливают РАЗНОЕ собственное время — подлинная дилатация времени, а не копия.

beatsOf(name) → целочисленный счёт битов N_i мировой линии i (тик регистра).
tauOf(name) → взвешенное метрикой собственное время τ_i (целочисленно-привязанное на битах; законы L1–L6).
Ядро также ВЛАДЕЕТ штампующими часами: stamp(t) = ⌊(t·RATE − c0)·SPP / rate⌋ отображает время реплицированного события t в ОБЩИЙ шаг — механизм, что делает каждый вход детерминированным (см. ниже).

Зависимость, нарисованная

                    proper time τ  (kwe-tau: per-slot beat counters N_i, τ_i)
                    │
       ┌────────────┼───────────────────────┬───────────────────────────┐
       │            │                        │                           │
   (timeless:    supplies Δτ            supplies N_i               supplies stamp(t)
    NOT on τ)     (aging interval)      (register tick)            (shared-step gate)
       │            │                        │                           │
       ▼            ▼                        ▼                           ▼
  ℂ* ALGEBRA   ω·Δτ AGING            REGISTER PRECESSION         DETERMINISM
  compose/     (evalAt /             φ ← φ + ω per beat          every input stamped
  invert/apply the recall angle)     (regH hashes N_i)           at a shared step
  record/lift  = HOLOGRAPHY'S        = the U(1) register         = "every input a pure
  FREEZE       HEADLINE              file evolving in τ           fn of (k, shared state)"

Половина 1 — ВНЕВРЕМЕННАЯ: группа и хранение НЕ нуждаются в часах

Групповой закон lensC1 и record/lift-как-apply/invert — чистая алгебра — заморозьте часы, и они всё равно держатся. В medium-u1.js:

record (_recordV) — оператор записи { mode:'id', phase, gain:1, kx:0, ky:0, … } и круговой рейс поля stepEyeN(+DT) / stepEyeN(−DT) не ссылаются на τ.
store — пластина замораживает dop (дескриптор (M,O)) + p (поле). Заморозка (M,O) вневременна́.
compose / invert / apply (soliton-algebra.js) — не берут временно́го входа. compose(op, invert(op)) = id независимо от любых часов.

Так что утверждение «голография = apply/invert на группе» стоит БЕЗ собственного времени. Вы можете записать, поднять и записать-сквозь-линзу с замороженным τ. Группа — это пространство хранимых моментов; она существует статически.

Половина 2 — τ-ВЕДОМАЯ: всё, что ЭВОЛЮЦИОНИРУЕТ

(a) Угол вызова — ЗАГЛАВНОЕ голографии `[RECALL-∠] = ω·Δτ`

Эквивалентность, которая И ЕСТЬ демо — старение-поля ≡ старение-дескриптора — не может быть вычислена без битовых часов. При store пластина записывает счёт битов W; при вызове интервал старения — это РАЗНОСТЬ битов:

store:   plate.bw = beatsOf('W')            // N_W at record time   (a τ quantity)
recall:  Δτ_W     = beatsOf('W') − plate.bw // = N_now − N_store    (beats elapsed on W's worldline)
         Δ_desc   = wrap( ω · Δτ_W )        // (B) the 6-float descriptor prediction
         Δ_field  = wrap( ∠(M_now) − ∠(M_plate) )   // (A) the 128 KB field round-trip
         EQUIVALENCE:  | Δ_field − Δ_desc | ≈ 0      // the two agree

Δτ_W — это beatsOf('W')_now − plate.bw — чтение часов мировой линии. Уберите часы, и нет Δτ, следовательно нет ω·Δτ, следовательно нет эквивалентности для доказательства. Дескрипторная половина голографии τ-гейтирована; лишь полевая половина выживает без неё (и тогда лишь как не-предсказанный круговой рейс, а не продемонстрированный закон).

Алгебра даже называет операцию: evalAt(op, dτ) = phase + prec + ω·dτ — предсказанный угол на dτ единиц собственного времени ВПЕРЁД. Вызывающий ДОЛЖЕН поставить dτ из часов; группа даёт закон, τ даёт аргумент.

(b) U(1)-регистр — прецессия на бит

Фаза наблюдателя не статична; она ПРЕЦЕССИРУЕТ, и прецессирует в собственном времени — раз на бит:

per beat of worldline i:   φ_i  ←  wrap( φ_i + ω_i )        // ω = the lensTau dial (rad / beat)
so after N_i beats:        φ_i(N_i) = φ_i(0) + ω_i · N_i     // the register ages linearly in τ

В medium-u1.js это блок «W AGES», привязанный к ОБЩЕМУ 21-шаговому такту, так что оба пира прецессируют на идентичном шаге: if ((k+1)%21===0) { beat('W', …); φ_W ← wrap(φ_W + ω) }. Содержимое регистра regH хеширует beatsOf(s.name) на слот — так что детерминизм точной арифметики регистра ВКЛЮЧАЕТ собственное время. Регистровый файл — это фаза U(1), эволюционирующая в τ; заморозьте τ, и регистр перестаёт быть компаратором часов.

(c) Детерминизм — штампующие часы ЕСТЬ τ-ядро

Каждое разветвление, которое дуга medium-u1 закрыла (свап ядра, ползунок refAmp, шаг рождения V), было исправлено ОДНИМ ходом: заштамповать вход к общему шагу через _tauK.makeQueue(...) и слить его в цикле драйва. Закон, что закрыл дугу — «каждый внешний вход должен быть чистой функцией от (k, общее состояние), применённой на общем штампованном шаге» — это сервис τ-ядра (stamp(t)). Так что детерминизм, предпосылка для ВСЕХ распределённых законов, едет на штамповании ядра собственного времени. (См. kwe-tau L1–L6: счёт-по-сроку, а не сырая длина, повторная привязка эпохи держит k непрерывным и т.д.)

(d) Много-наблюдательская дилатация времени — причина, почему τ ПО-СЛОТНОЕ

Поскольку каждый слот несёт СВОЁ τ_i (не глобальные часы), сохранённая/загруженная мировая линия может стареть с иной скоростью, чем живая: реестр τ измерил V состарился на ~30 τ-единиц, пока W состарился на <1, побайтово идентично между пирами. Именно это делает V подлинно ДРУГИМ наблюдателем, чем W — иным количеством собственного времени при тех же координатных шагах — а не просто копией. По-слотное τ — это предпосылка того, чтобы у много-наблюдательского регистра были различные часы для сравнения (link(a,b) = ∠b − ∠a, калибровочно-инвариантное попарное чтение).

Закон в одну строку

ℂ-группа — это пространство моментов; собственное время τ — это параметр, что движется сквозь него.* Хранение и алгебра вневременны́ (только-группа); старение, прецессия, штампование детерминизма и дилатация времени τ-ведомы. Заморозка/подъём абстрактной голографии — только-группа; её заглавная эквивалентность [RECALL-∠] = ω·Δτ — а с ней регистр-как-часы и распределённый детерминизм — суть предпосылки собственного времени. τ — не один закон среди законов KWE; это параметр эволюции, в котором записаны динамические законы.

(Полная теория τ: [[proper-time-metric]] (реестр, врата 1–3, метрический закон), [[computer]] (эксперимент с регистром). Ядро: public/kwe-tau.js, законы L1–L6.)

medium.js против medium-u1 — цикл драйва, coevo против virtGo, и где живёт ОТО

Ре-архитектура слотов изменила машинерию транспорта, но не законы физики — и она ПРИПАРКОВАЛА одну вещь (обратную связь материя↔геометрия), которую ℂ* может вернуть более честно. Этот раздел делает diff точным и отвечает, где честное ОТО / «скорость света» на самом деле находится.

Цикл драйва, бок о бок

Оба цикла шагают солитон идентично на самом внутреннем уровне — applyEyeSuperpose(β·att) → stepEyeN(1) → applyEyeNlSpm(−γ, isat) → applyEyeEnergyCap(e0). Разница — в АРХИТЕКТУРЕ вокруг этого шага:

	medium.js (оракул)	medium-u1
тело цикла	~60 строк inline: сливы kernel/shift/att/sig/virt/reactor, mux, coevo-поводок, selfClk, τ, связь	~15 строк: свап-ядра, слив-shift, слив-reg, mux, один W-шаг, W-стареет, Q-считывание
цель	`_transPx/_transPy` (скаляры) ИЛИ `_coevoGx/_coevoGy` (ОТДЕЛЬНЫЙ поводок), выбираемые `_coevoOn`	`W.leash.state.gx/gy` — ОДИН путь, без ветвления
перестройка att	`_rebuildAtt()` — замыкание над `_lensObj/_coevoOn/_attAY/_attRot/_cubeField/…` (~7 зависимостей)	`W.movAtt(gx,gy) = lensC1.apply(Op, ψ_base)` — чистая операция дескриптора
mux	`_muxVirtualStep(k, att, Q)` — W + частный случай «виртуальные фазы»	`_mux.step(k, slots, att)` — ОДНОРОДНЫЙ массив слотов
детерминизм	охочен по-входу месяцами (каждый слив/каденция — пережитое разветвление, задокументировано inline)	ТЕ ЖЕ законы, ВЫНЕСЕНЫ (`makeStampedInput`, `syncClockRate`, постановка ядра)

Цикл оракула ЕСТЬ накопленная лаборатория — каждый слив это разветвление, которое он пережил. Цикл medium-u1 — это те же законы, переформулированные как поведения слотов, с исправлениями разветвлений, поднятыми в переиспользуемые помощники. Ни один закон физики не был отброшен; оркестрация была реорганизована, а частные случаи (V-как-не-слот) сделаны однородными.

coevo (исходный) против virtGo (U1) — и почему он ПРИПАРКОВАН, а не потерян

Это острейшая разница, и она концептуальна.

⟲coevo (оракул, _coevoLeash) — это ЗАМКНУТЫЙ КОНТУР ОБРАТНОЙ СВЯЗИ между материей и геометрией. Поводок читает ПОЛЕ: l = ampCorr(field, att), обучает медленную базовую линию фиксации и продвигает цель на шаг, масштабированный sig = f(l/baseline). Если солитон теряет когерентность (отстаёт), sig→0 и цель ЖДЁТ, пока материя нагонит. Его собственный комментарий: «материя говорит геометрии, как далеко она может зайти — петля Эйнштейна на уровне транспорта». Состояние солитона гейтирует движение своей цели.
virtGo + только-дескрипторный leashAdvance (U1) продвигает gx/gy с полной детерминированной скоростью ≤1px/бит БЕЗ чтения поля (sig=1 всегда). Цель движется по фиксированному расписанию; пинованный солитон следует.

Так что закон движения изменился с полево-гейтированного (коэволюционного) на только-дескрипторный (разомкнутый контур). Это было НАМЕРЕННОЕ решение о детерминизме (чтение ampCorr(field) было локальной для пира обратной связью, что разветвляла solH; его удаление сделало gx/gy чистой арифметикой → в regH → регистр расцеплён от детерминизма поля).

Он ПРИПАРКОВАН, а не потерян: leashAdvance держит полево-питаемую ветвь дремлющей (if (field && corr) …), готовой ровно к возврату, описанному далее.

«Раз у нас есть ℂ*, почему нельзя достичь петли Эйнштейна?» — МОЖНО, более честно

Можно — и ℂ* — это ровно то, что делает это честным. СОДЕРЖИМОЕ «материя говорит геометрии, как далеко идти» не требует чтения сырого поля; оно требует НАБЛЮДАЕМОЙ МАТЕРИИ, питающей обратно в метрику. ℂ* поставляет одну, что УЖЕ детерминирована: координату gain (амплитудная / энергетическая СС; logGain = ln r).

На срезе lensU1 (пинованном) gain ≡ 1: у солитона НЕТ амплитудной свободы — вот ПОЧЕМУ он застрахован от убегания И почему нет честной обратной реакции материи. Геометрия действует на материю; материя не может действовать обратно через амплитуду, которой не обладает.
На срезе lensC1 (отпинованном) gain свободно: ЭНЕРГИЯ солитона — первоклассная координата РЕГИСТРА. capGain(op, rMax) — это буквально энергетический потолок как операция алгебры.

Так что честная ℂ*-петля Эйнштейна — это: продвижение поводка, гейтированное gain солитона (ДЕСКРИПТОРНОЙ наблюдаемой), а не ampCorr(field) (чтением поля). sig = f(logGain) вместо sig = f(ampCorr(field, att)). Обратная связь ВЫЖИВАЕТ — энергетическое состояние материи дросселирует собственный транспорт — но сенсор перемещается с ПОЛЯ на ДЕСКРИПТОР, так что остаётся в regH (детерминировано, без локального для пира чтения).

Почему ℂ-версия БОЛЕЕ честна, а не только детерминирована:* собственный закон сохранения среды ([[gr-medium-conclusions]] §4) гласит: «любая опора замкнутого контура, включающая собственный выход оператора, самообманывается; честны лишь глобально-нормированные наблюдаемые качества». coevo-контур ampCorr читает СОБСТВЕННЫЙ продукт оператора (пинованное поле ≈ att) — частичный самообман. gain-гейтированный контур читает НЕЗАВИСИМУЮ координату регистра — ровно честную наблюдаемую, которой требует закон. Так что ℂ* не просто восстанавливает петлю Эйнштейна; она исправляет изъян самоссылки, который нёс полево-питаемый вариант.

Где честное ОТО? «Скорость света»?

Среда честна в том, что есть ДВА СЕКТОРА с двумя разными ответами ([[gr-medium-conclusions]] §2–3):

Канал позиции (оператор / метрика) — НЕТ предела скорости. «Самим пространством можно командовать с любой скоростью» (измерено 1148 px/такт при полной фиксации — аналог эволюции-метрики / инфляции). И virtGo, и coevo живут ЗДЕСЬ. В этом канале нет c ПО ЗАМЫСЛУ: это координатный транспорт, а не движение СКВОЗЬ пространство. Исход ограничивает память (закон гало), а не скорость.
Канал импульса (мобильная материя) — имеет НАСЫЩАЮЩУЮ v(p): v → v* по мере роста импульса (релятивистская ФОРМА скорости, измеренная на голой подложке; зонно-структурированная на нативном кольцевом ядре).

Так что честная «скорость света» — это v* в секторе ИМПУЛЬСА — потолок, к которому самодвижущийся солитон приближается, но никогда не превышает. Она ИЗМЕРЕНА, ЭМЕРДЖЕНТНА из дисперсии среды (зонная структура кольцевого ядра), НЕ жёстко зашитая константа. Вакуум шрёдингеровского класса (ω ∝ k², без лоренцева конуса), так что релятивистская структура НЕ живёт в вакууме — она живёт в МАТЕРИИ (насыщение v(p)) и в слое ЧАСОВ (по-слотное τ, измеренная дилатация времени).

Где ℂ делает ОТО более честным:* исходный вариант двигал материю почти ЦЕЛИКОМ через канал ПОЗИЦИИ (деформация оператора/метрики), потому что пинованный солитон НЕ МОЖЕТ самоадвектироваться (мобильность ⊥ устойчивости — γ=20 закручивает его фазу и не принимает импульса; γ=1 движется, но не связывается). Это честно, но ОДНОСТОРОННЕ: материя — пассивный ездок на командуемом пространстве. ℂ открывает канал ИМПУЛЬСА регистру* — отпинованный солитон имеет живую амплитуду → может нести импульс → имеет v(p) → приближается к v*. Так что «скорость света» становится свойством СОБСТВЕННОЙ ДИНАМИКИ МАТЕРИИ, а не командой метрики. Двухканальный закон (позиция: нет предела; импульс: v*) УЖЕ и есть честное ОТО; ℂ* — это то, что позволяет слоту действительно ИСПОЛЬЗОВАТЬ канал импульса, а не только ездить на позиционном — что также заново включает честную (gain-гейтированную) петлю Эйнштейна выше. Это ОДИН и тот же разблок: верните материи её амплитудную СС, и обратная реакция и реальный потолок скорости следуют оба.

Честная оговорка (компромисс детерминизм ↔ живость)

По умолчанию у medium-u1 — КОМПАКТНЫЙ / пинованный срез (lensU1, gain≡1): застрахован от убегания, регистр-точен, побайтово-детерминирован — но с ЗАКРЫТЫМИ (припаркованными) каналом импульса и обратной реакцией материи. Некомпактный срез (lensC1, отпинованный) открывает оба — честную v*, gain-гейтированную петлю Эйнштейна, подлинную самомодификацию — ценой того, что apply больше не унитарно, а мировая линия может расходиться в r (capGain её ограничивает). Так что выбор явен и обратим на слот: оставаться пинованным ради детерминизма или unpin-нуть слот, чтобы дать ему импульс + обратную реакцию + предел скорости. Физика не отсутствует; это переключатель управления (pin/unpin), который архитектура слотов делает первоклассным. См. раздел ℂ*-алгебры выше (lensU1 против lensC1) и [[gr-medium-conclusions]] (двухканальный закон, стена мобильности, v*).