Общерелятивистские мировые линии.

0. Тезис в одном предложении

Собственное время — это закон платформы; физика — закон приложения.

Классическая модель репликации Croquet/TeaTime даёт каждому пиру одни общие логические часы. Новая дуга даёт каждой мировой линии внутри мира свои собственные часы — часы, относительно которых платформа тактирует, снимает снимки, реплицирует и диспетчеризует, никогда не зная, почему они тикают. Это разделение — ядро знает что у мировой линии есть часы, но никогда — почему — оказалось всей архитектурой. Всё нижеследующее — это развёрнутое то предложение.

1. Классическая базовая линия: одни часы на мир

Croquet/TeaTime (и классический Krestianstvo поверх него) достигает детерминированной репликации тремя ходами:

рефлектор упорядочивает все события и штампует их одним логическим временем;
каждый пир выполняет одну и ту же детерминированную мировую программу относительно этого потока;
фьючерсы (ctx.future(dt, msg)) планируют вычисление в этом одном времени.

Это в лучшем случае специально-релятивистский мир: есть единственное глобальное «сейчас», каждая часть мира стареет с одной скоростью, а future(dt) означает «dt единиц того времени». Он побайтово совершенен и он жёсток: объект, который вычисляет медленнее, спит или живёт внутри разделяемого по времени слайса, не имеет способа это сказать — настенные часы тянут всё с одной скоростью.

KWE наследует все три хода без изменений (рефлектор, W.reduce, глаголы как штампованные события). Что он добавляет — это четвёртый:

каждая мировая линия может нести часы собственного времени τᵢ, продвигаемые своими собственными битами, и вычисление может планироваться в этих часах (ctx.futureTau(dτ, msg)).

2. Что «ОТО» здесь означает — операционально, а не метафорически

Каждое утверждение ниже — это измеренный результат из лаборатории среды (ссылки в proper-time-metric.md §§9–12 и реестре computer.md):

понятие ОТО	реализация в KWE	измерено
мировая линия	mux-слот / узел со своим счётчиком исполненных шагов kᵢ	по-слотное τᵢ вживую с врат 3
собственное время	τᵢ = биты + дробь, продвигается только собственными битами слота	τ монотонно, переносится снимком, побайтово идентично
дилатация времени	N-канальный mux запускает каждый слот при 1/n собственной скорости; припаркованные слоты не стареют	V состарился на 30 τ-единиц, пока W — на <1, побайтово идентичные пиры
парадокс близнецов	путешествия делают биты; стояние — нет; прецессия ∫ω·dτ монотонна	Δφ_V = ω·Δτ = 2.078 против 1.900 предсказанных; нулевое плечо W ровно 0
часы как наблюдаемые	регистр прецессирует ω на собственный бит → фаза = ω·τᵢ	наклон компаратора = ω с точностью 0.1%
путь-зависимое старение, читаемое из памяти	пластины штампуют систему отсчёта записавшего наблюдателя + счёт битов	[RECALL-∠] Δ = ω·Δτ_W = 0.800 точно
связанные часы	рёбра между регистрами = Курамото осцилляторов собственного времени	втягивание, подавление, P_lock на встречу — всё вживую
одновременность не глобальна	консенсус на уровне реестра (побайтово идентичная история) ≠ консенсус на уровне фазы (общее «сейчас»)	язык Адлера — это бюджет консенсуса

Глубокая находка: репликация и одновременность расцепляются. Два пира могут быть побайтово идентичны в каждом хеше, тогда как мировые линии внутри их общего мира стареют с разными скоростями и честно расходятся о «сейчас» на ω·Δτ. Консенсус на уровне истории безусловен; консенсус на уровне фазы имеет релятивистский бюджет.

3. Стек ядра (законы, все импортируемые)

Всё нижеследующее не зависит от приложения, протестировано без графики и импортируется как полной средой, так и тонкими приложениями. Это и есть новое ядро KWE.

3.1 `kwe-tau.js` — часы мировых линий и τ-диспетчеризация

makeTauKernel({ stepsPerPhase, flatL })
  .beat(name, kp, k)      a worldline's clock ticked (kp = its proper counter, k = shared step)
  .advance(name, kp)      no beat this step (τ advances fractionally, clamped below the next integer)
  .tauOf / .beatsOf       read a worldline's clock
  .makeQueue(name, {clock, guard})   a verb queue; drained against COORDINATES or against a CLOCK
  .stamp / .reanchor / .setEpoch     shared-step stamping + the epoch flip law (L5)
  .save / .restore / .hash           full snapshot codec (queues + clocks + epoch)

Законы детерминизма, которые оно кодирует (каждый оплачен живым разветвлением):

L1 — каждый гейт диспетчеризации есть чистая функция от (k, общее состояние). Длина очереди не является общей (тайминг вытягивания локален для пира); счёт готовых к сроку — является.
L2 — никакого применения на границе кадра: глаголы действуют только на штампованных общих шагах.
L3 — авторски-свежий: внешняя команда действует однажды в своей авторской координате; всё сверх того движется лишь по мере тиков часов локальной материи (отставание ≤ 1/τ-единицу).
L4 — τ монотонно и самоисцеляется; свежее состояние битов требует сброса τ.
L5 — безопасность эпохи: при смене скорости перештампуйте каждую будущую запись из её сырого времени.
L6 — переносите снимком всё, от чего зависит состояние (kv-разветвление было одним RNG).

ctx.futureTau(dτ, msg) на уровне мировой программы: узел объявляет __clock: (state) => number, и фьючерсы срабатывают, когда узел состарился, а не когда сдвинулись настенные часы. Нет часов ⇒ futureTau ≡ future в точности (гарантия no-op). τ-припаркованный узел СТАБИЛЕН — спящие миры не стоят ничего и пробуждаются тем, что продвигает их часы.

3.2 `medium-core.js` — законы движка (стадии извлечения A–C4)

makeStepClock({stepsPerPhase})   §7.44: target(mon) = ⌊(mon−c0)·spp/rate⌋ — the mux divides
                                 the STEP BUDGET, not the wall; reanchor(k,r) keeps k continuous
                                 at rate flips (bit-exact vs the legacy inline law)
muxClocks(k, nSl, beats)         the two-clock law: fine buffer-ownership ph = k % nSl;
                                 coarse coupling/τ clock capPh rides BEATS, not the rotation
makeCouplingStore()              the edge matrix + the capture law (capture gated PURELY on the
                                 coarse-clock change; sources frozen from canonical stores;
                                 any edge write invalidates the cursor)
makeObserverBank(n)              observer descriptors as ONE store: {mode, phase, kx, ky, A,
                                 tx, ty, beta, omega, prec} per slot + snapshot codec (+ legacy)
lensU1                           the observer-lens algebra (see §6)
chainMeter(slots, {G, through})  the one link-read: pairwise overlaps, raw (pred/mdl/algDefect)
                                 or through-lens (the observed chain)
normalizeVirtEvent(e)            the verb WIRE SCHEMA — one source of truth at the pull
applySettingsVerb(vq,k,ops,dials) the settings-sector verb table (lensset/lenstau/refamp/…)
applyVirtVerb(vq,k,S,io)         the V-sector optics verb table behind a stores contract

Граничное правило, сформировавшее каждое решение об извлечении: ядро знает ЧТО у наблюдателей есть дескрипторы, часы и очереди — физика (детекторы битов, сетки, откалиброванные константы, содержимое оператора) остаётся на стороне приложения. Законы mux-планировщика переехали в ядро; его оркестрация (что делает шаг) — нет, потому что её перенос дал бы ядру знать, почему среда тикает.

4. Контракт материи — что приложение должно предоставить

Чтобы работать «на GR KWE», приложение поставляет ровно четыре вещи:

Состояние для каждой мировой линии (поле, голос, клетка — что угодно), мутируемое только на штампованных ядром общих шагах, в детерминированном порядке float-операций.
Функция шага: что один собственный шаг делает с состоянием одной мировой линии. Это физика. Движок вызывает её для слота, владеющего текущим шагом (muxClocks.ph) — mux разделяет по времени бюджет шагов, что и делает собственную скорость 1/n реальной.
Источник битов на мировую линию — что угодно, что детерминированно говорит «эта мировая линия только что тикнула» из (её состояние, её собственный счётчик):
- детектор ряби фиксации среды (амплитудная корреляция с пином — материя бьёт);
- метроном в собственных шагах (музыкальный бит — rhythm.js);
- IFS-каскад (биты = собственные события фрактальных часов — hologram_world);
- часы сходимости (биты = итерации релаксации) — сконструированы, безопасны от взаимной блокировки через закон живости цепи запуска. Ядро получает beat(name, kp, k) / advance(name, kp) и никогда не спрашивает, какой.
Канонические хранилища — читаемая CPU истина для состояния каждой мировой линии, потому что закон захвата связи и каждое чтение измерителя читают хранилища, а не переходные буферы.

Чего приложение не должно делать: читать настенное время, гейтировать что-либо на локальных для пира величинах (границы кадров, длины очередей, владение GPU-буфером) или мутировать реплицированное состояние вне штампованного шага. Каждое из этих правил — это именованное разветвление в реестре.

5. Почему ОТО не нуждается в полных уравнениях солитона

Это был решающий вопрос, и ответ измерен: да, это возможно — относительность живёт во временны́х законах, а не в УЧП подложки.

Разложение:

Дилатация времени — это закон бюджета шагов (makeStepClock): N-канальный mux даёт каждой мировой линии 1/n шагов. Это планирование, а не гидродинамика.
Старение — это биты, а источнику битов нужно лишь быть детерминированной функцией собственного состояния и счётчика мировой линии. Биты среды возникают из ряби фиксации солитона; rhythm.js доказывает, что 8-флоатовый гармонический голос — или голый метроном — питает то же ядро и производит те же эксперименты близнецов, наклоны компараторов и штампы вызова.
Регистры, прецессия ω·τ, цепной измеритель, штампы вызова — все они оперируют над любым комплексным состоянием со скалярным произведением. chainMeter не знает, являются ли его поля 256×256 солитонами или четырьмя гармониками.

Так что тонкое ОТО-приложение реально: observers.js (16×16 шрёдингеровская игрушка) и rhythm.js (синтезаторный голос; ~8 флоатов материи на мировую линию) запускают полный релятивистский аппарат — часы мировых линий, дифференциальное старение на метрономе (парадокс близнецов без путешествий: два темпа + lensTau), слышимую дилатацию времени, наблюдатель- относительную музыкальную память.

Что полная солитонная среда всё ещё уникально даёт — и почему она остаётся лабораторией:

эмерджентные биты (часы возникают из собственной динамики фиксации материи, а не из авторского темпа — разница между нахождением часов и объявлением их);
самохостящиеся операторы (геном/линза как материя, §7.88–§7.101);
адресуемая по содержимому память с подлинными бассейнами захвата (бистабильный регистр);
откалиброванная физика взаимодействия (β, κ, утечка — измеренные, с честными режимами отказа: износ, полы разрушения, диапазоны захвата).

Слоган: ядро делает любую материю релятивистской; среда — это где законы были открыты и всё ещё проверяются.

6. Слой наблюдателя — u-регистр и алгебра линз

Вторая половина дуги: наблюдатели как первоклассные значения.

Кортеж наблюдателя — каждый слот уже им является: (readOp, __clock, register) = (его дескриптор линзы, его часы мировой линии τᵢ, его пластина + фазовый регистр). u-регистр — это цепь W→V→P1→P2 — мировая линза сквозь ловушки наблюдателей — и она измерена как путь-упорядоченное произведение:

lensU1 — алгебра. Элементы {mode, phase, kx, ky, A, tx, ty, beta, omega, prec}; сектор id/phase — абелев U(1) (фазы связей складываются точно — дефект цепи ≡ 0 есть заявленный модельный закон); metric/gauge композируются полупрямым произведением (A_b·A_a; наклоны тянут назад k·A⁻¹; трансляции вносят точную фазовую поправку), с invert, замыкающимся к тождеству, и apply, доказанно точным на решёточно-точных отображениях. β намеренно не применяется чтениями — жёсткость пина есть динамика, а не то, что чтение делает с полем.
Два канала считывания: chainRead (сырые поля + предсказание алгебры на связь; mdl = измеренное − предсказанное, чей дрейф и есть физика) и chainSee (каждое поле читается сквозь свой readOp — ψ_out = Op·ψ_in как измеритель; сквозь линзу дескриптор есть часть измерения). Измерено: mdl на уровне миллирадиан; тождество U(1) link_seen = link_raw + pred точно; метрическая линза стоит когерентности, почти никакой фазы (vis 0.91→0.18 при rot 0.3, тогда как фаза сдвинулась на ~0.01).
Граница честности со стороны чтения: сектор metric/tilt формует то, что наблюдатели видят (измерители, рендер ∠-линзы); динамика потребляет только фазу U(1). Заставить пересборку действовать на сохранённых операторах — это реальное преобразование материи — своя будущая глава.
Наблюдатель-относительная память: пластины штампуют систему отсчёта записавшего наблюдателя и счёт битов; вызов печатает разность возрастов как фазу ([RECALL-∠]), верифицированную точно на уровне реестра и на уровне поля (вызванный мир действительно состарен).

τ входит в линзу: lensTau(ω) заставляет опору каждого слота прецессировать ω на его собственный бит — регистр становится интерферометрическим компаратором часов, а вид каждого наблюдателя зависит от его собственного старения. Это четвёртая, временна́я компонента алгебры линз, и именно она связывает дугу памяти с дугой относительности.

7. IFS-часы, геометрический оператор и futureTau — одна композиция

Как части, что дуга растила раздельно, композируются в одну историю ядра:

IFS-каскад — это часы, сделанные из геометрии. Аффинные отображения генома — это линза; запущенные рекурсивно, они — фрактальные часы, чьи внутрикаскадные задержки суть содержимое генома во времени — поэтому перманентно координатно-авторские (механизм часов не может ждать часы, которые он определяет). Только межцикловый клей едет на τ: ctx.futureTau(N_FRESNEL_ROOTS, launchSibling) смещает слоты в материальном времени, с завершающим запасным вариантом, поставляющим живость (закон: τ-тактируемое расписание, чья цель может отказать в событии, нуждается в пути живости, независимом от часов, которые нёс отвергнутый; остановка была поймана вживую и исправлена).
Геометрический оператор — это материя (§7.97/98): самохостящийся оператор — это преобразование пространства, а не объект в нём — вот почему метрический сектор алгебры линз композируется как аффинные отображения и почему «запись сквозь линзу» — это рождение в повёрнутой системе отсчёта, а не украшение.
futureTau обобщает всё это: любой узел с __clock планирует в собственном старении. IFS-часы, часы ряби, метроном, цикл сходимости — все они просто разные ответы на «почему эта мировая линия тикает», а платформа никогда не спрашивает.

8. Поверхность глаголов (реплицированный API)

Все изменения состояния — это глаголы: штампованные рефлектором события, зажатые моделью мира, несомые wire-схемой, слитые на штампованных ядром общих шагах. Три места схемы — зажим мира → pull (normalizeVirtEvent, единственный источник истины) → таблица слива — причём pull — это исторически забываемое (оно молча срезало новые поля, пока не было централизовано).

глагол	сектор	значение
`record` / `recvia(φ)`	optics	V рождается как копия W — сквозь линзу для recvia (поле+пластина+оператор повёрнуты вместе; ловушка начинается в повёрнутой системе отсчёта)
`aphase(a, slot)`	optics	повернуть опору регистра (запись удержания M-a″)
`lenstau(ω)`	settings	каждая опора прецессирует ω на свой собственный бит (регулятор компаратора)
`lensset(slot,{kx,ky,rot,scl,tx,ty})`	settings	расширенный readOp (metric/gauge) — со стороны чтения
`refamp(slot, m)`	settings	регулятор жёсткости пина β (баланс моментов)
`edge(a,b,κ)`	coupling	знаковая симметричная связь регистров (машина XY/Курамото)
`store` / `recall`	memory	банк пластин со штампами наблюдателя; recall = адресуемое-по-содержимому возобновление + [RECALL-∠]
`boot` / `kill`	slots	поднять пластину в живой слот / освободить один
`mux` / `hold` / `mirror` / `selfclock`	medium	разделение по времени, пин, контрфактуальное зеркало, бит-ведомое вращение
`tempo(slot,n)` / `beatmode(slot)`	thin apps	музыкальный регулятор собственного времени; выбрать источник битов вживую
`checkpoint`	join	припарковать полный снимок движка в мире; подрезать лог за ним

Измерители (локальные для пира, чистые функции реплицированного состояния — пиры совпадают при равном шаге): lensOps (дескрипторы), chainRead/chainSee (два канала), regPhase (углы + биты + хеши), edgeStatus, tauKernel. Консольные драйверы (gates-console.js, драйверы sweep/twin/Kuramoto) построены из них.

9. Две архитектуры входа — и как каждая отказывает

	вход по снимку (среда)	вход полным переигрыванием (тонкие приложения)
отгружает	полное состояние дословно (medSnap*, ~МБ)	(время, лог глаголов ≤512) + опциональная контрольная точка
входящий	возобновляет на k лидера	заново выводит вселенную из k=0 (или контрольной точки)
сила	O(1) время входа	переигрывание и есть верификация — входящий должен заново прийти к тому же хешу
режим отказа	отсутствующее состояние (kv-разветвление: один неотгруженный RNG)	устаревшие ворота (закон переигрывания ниже)

Закон переигрывания с устаревшей целью (пойман вживую, подтверждён симуляцией): цикл шагов, способный пересечь смену скорости, должен пересчитывать свою цель после каждого слитого глагола; потолок бюджета ограничивает работу кадра, но никогда не замораживает ворота. (Замороженная цель перелетает на (chunk·Δrate/rate) фантомных шагов, затем входящий сидит замороженным, пока настенные часы не нагонят.) Живые кадры это скрывают (≤ один кадр в полёте, идентичный на пирах); чанки переигрывания это обнажают. С исправлением холодное переигрывание и живая история приземляются побайтово-равными — что также является сильнейшей верификацией перештампования L5 ядра.

10. Рецепт: написание нового тонкого приложения

observers.js (визуальная игрушка) и rhythm.js (музыкальная материя) — два шаблона; оба ~300 строк, ~80 из которых — физика. Скелет:

Мировая программа: держать только (time, seq, log, snap). Зажимать глаголы; добавлять в лог; обрабатывать checkpoint сохранением снимка и подрезкой лога. Больше ничего.
Движок (в замыкании рендерера — чистая функция общего времени + истории глаголов): инстанцировать законы — makeObserverBank, makeStepClock, makeTauKernel + очередь глаголов, makeCouplingStore; держать по-слотное состояние + канонические хранилища.
Цикл кадра: вытянуть невиденные глаголы (normalizeVirtEvent, штамповать в том же масштабе часов, что и цель — рефлекторное wallTime считает пульсы, а не мс); затем while (done < CAP) { tgt = clk.target(now); if (k >= tgt) break; drain(k) → applySettingsVerb ∥ your verb table → reanchor; {ph} = muxClocks; capture if due; stepSlot(ph); k++; done++; } — цель пересчитывается каждый шаг (§9).
Физика: ваш stepSlot + ваш источник битов, питающий tauK.beat/advance.
Рендер: рисовать/играть реплицированное состояние — панели сквозь собственный readOp наблюдателя, если вы соблюдаете переключатель ∠-линзы; аудио срывается, когда общий движок пересекает бит. Рендеры локальны для пира; состояние — никогда.
Инструменты: подключить chainMeter, lensOps, хеши в статусную строку; нести ловца-остановок (брошенный движок должен сказать это один раз, а не замереть молча).

Что вы получаете за эти ~300 строк: реплицированные часы мировых линий, дилатацию времени, эксперименты близнецов, дескрипторы наблюдателей с композирующей алгеброй линз, физику связанных часов, наблюдатель-штампованную память и двух-пировую побайтовую верификацию — ничего из этого не написано вами.

11. Отличие от классического Croquet/Krestianstvo, резюмировано

	классический	KWE-GR
время	одни логические часы на мир	+ часы собственного времени на мировую линию
планирование	`future(dt)` в настенном/логическом времени	+ `futureTau(dτ)` в собственном старении узла
дилатация	невыразима	закон бюджета шагов; припаркован = не стареет
наблюдатели	неявные (вид)	первоклассные значения: (readOp, __clock, register)
наблюдение	рендер = состояние	рендер = Op·состояние, а Op композируется как группа
память	снимки состояния	+ наблюдатель-штампованные пластины; вызов читает разрыв возрастов
связь	передача сообщений	+ откалиброванная связь регистров (Курамото часов) с измеренным бюджетом консенсуса
консенсус	побайтовое тождество = согласие	побайтовое тождество ≠ общее «сейчас»: фазовый консенсус имеет релятивистский бюджет (язык Адлера)
бремя приложения	вся симуляция	ТОЛЬКО материя: состояние + шаг + источник битов

Классический стек отвечает на «вычисляют ли все пиры один и тот же мир?». GR-стек добавляет вопрос, который классический стек не мог задать: «согласны ли обитатели этого мира, который час?» — и даёт на него измеренный, бюджетированный, на-встречу ответ.