The Mathematical CityInstrumentE0 provedE1 computedE2 simulated

The Quantum Clock

A qubit held inside the protected 47-dimensional sector of V2⊗V2⊗V2. Its hand is the phase between the Casimir sectors C = 6 and C = 30. It reads its own proper time, it keeps that time exactly while recovery pulls every leak back, and two of them on different worldlines drift apart by exactly (N1 − N2)ω.

Built from the corpus’ own formalism: the Casimir selector and P47, the Clock Math Lindblad theorem, the prime 47-cycle, the modular synchronisation clock, the time-chain identity, the E47 pullback metric, and the temporal quantum graph network. One forward tick of the clock is exactly the T gate of The Matrix.

Framework & E47 kernel
Nicholas Shane Kouns
Clock, engine & instrument
Claude (Anthropic), 19 October 2026
Arithmetic
float64, exact propagators, recomputed in this browser
Reference
Python TQGNN package · JavaScript parity to 10⁻¹⁴
Precision certificaterunning…see every check
InstrumentE0E1E2 clicks

The clock

The gold hand is the deterministic clock, −arg Tr(|a⟩⟨b| ρ), propagated with the exact matrix exponential of its Lindblad generator. The green hand is one monitored run of the same clock, whose recovery clicks are recorded with efficiency η. The eight labels are Matrix gate words: when the hand points at ST, the clock has done what T·T·T does. The marks round the rim are the prime 47-cycle.

clock (ρ)one run (clicks recorded)population in E47

coordinate time t0dimensionless units
proper time τ0N = 1
gold hand reads0error 0
green hand reads0error 0
clicks counted0click clock τ = n/λ
in E47 (retention)1stationary 1 − q
clock coherence |κ|0.5dephasing 0
clicks per unit τ0Fano F
dialects of the phase0;0,0prime tick 0/47
Clock

Temporal quantum graph neural networkE0E1E2 runs

A network of clocks

Each node is the same clock-memory unit on its own worldline. The graph Hamiltonian is QGNN message passing: exchange J(σ⁺σ⁻ + h.c.) and Ising Jzz Z Z between neighbouring clocks. In coordinate time every term is scaled by the lapse of the worldline it lives on, Ht = Σ NvHv + Σ NeHe, Lv,t = √Nv Rv. Faster clocks run slow, by exactly their lapse.

Phase of each clock relative to clock 1 (solid) against the drift (Nv − N1)ωt the lapses predict (dashed). With J = 0 and the matched clock they coincide to round-off; exchange between clocks on different worldlines is detuned by that same drift.
Built in this browserE0E1

Construct it from the carrier

Nothing on this page is typed in. The page builds the three spin-2 systems, the total Casimir C, its eigenspaces, the selector K = (C − 6I)(C − 30I), the projector, the clock states and the metric, then reads every number below off what it built.

Casimir spectrum of V₂⊗³. The gold bands, C = 6 and C = 30, are E47: 25 + 22 = 47 of 125.
‖Γⁿ − P‖₂ measured by matrix powers (dots) on the exact law (15/17)ⁿ (line), down to (15/17)²²⁰ = 1.0998 × 10⁻¹². Γ = I − K²/99144.
Select → Lock → Cycle. The 47-cycle on a basis of E47 (outer ring) and the torus clock on the 5×5×5 sites (inner) return together only after lcm(5, 47) = 235 steps. Drag the slider to step both.
The synchronisation clock z ↦ z² mod 5875 from z₀ = 2: two transient steps, then a 220-cycle (period 11 mod 47, 20 mod 125). Stepping U = Γ ⊗ T, the filter converges at (15/17)ⁿ without waiting for the clock, and at n = 220 the clock has returned.
Precision certificateE0E1E2

Every claim, recomputed

The same engine runs here, in a background thread, and in the repository’s test suite. Each check records the value it found, the target, the residual and the tolerance. Parity checks compare against numbers written by the independent Python reference with exact propagators.

MC-QCLOCK-PRECISION-20261019-001running
Committed certificatePython reference values

idcheckclassresidualtoleranceverdict
Bridgecity.quantum.state-receipt.v1E0E1

The Matrix bridge

Export a receipt from The Matrix Quantum Simulator and bring it here. The bridge checks its SHA-256 digest, then replays the circuit with the Matrix’s own gate arithmetic, in the order the diagram shows and in the order the gates were placed, and says which one the state matches. One qubit then becomes the clock’s logical qubit, |0⟩ ↦ |b⟩ (C = 30), |1⟩ ↦ |a⟩ (C = 6); the other two ride along. Under the matched clock, k forward ticks are exactly Tk, even with leak and recovery running, so the result goes back to the Matrix as a receipt it can open.

No receipt loaded.
clockmatched · c = 1 · γ = 20
Open The Matrix
ToolsE1

Automate

Sweep any parameter and get the numerical answer next to the closed form, as a table you can download. The same engine is importable from the page, scriptable from another window, and runnable from the command line and from GitHub Actions.

Population kept in E47 for each logical branch: numerical steady state (dots) on 1 − 4c²/(γ² + 8c² + 4Δ²) (lines).
Clock dephasing: exact slowest coherence mode (dots) and the second-order law ½γc²|z_a − z_b|² (line). The matched clock is identically zero.

Script it from the page

// in this page's console
const { NodeClock, sweep, runCertificate } = window.QuantumClock;
const clk = new NodeClock({ clock: 'linear', gamma: 10, eta: 1 });
clk.advance(100);            // coordinate time
clk.state();                 // τ, hands, clicks, retention …
sweep({ param: 'gamma', from: 2, to: 60, steps: 30 });

From another window or an iframe: postMessage({ type: 'QCLOCK_SET', params }) reconfigures the clock, { type: 'QCLOCK_GET' } answers with QCLOCK_STATE, and when embedded the page posts QCLOCK_CERTIFICATE to its parent once the certificate finishes.

Run it headless

git clone https://github.com/nicholaskouns-create/Time
cd Time
node --test tests/engine.test.js
node tools/qclock-cli.js certificate
node tools/qclock-cli.js sweep --param gamma --from 2 --to 60 --steps 30 --csv
node tools/qclock-cli.js run --tau 50 --clock linear --gamma 10
node tools/qclock-cli.js verify-receipt matrix-quantum-receipt.json
pip install -r requirements.txt
python tools/golden.py --check

GitHub Actions runs the tests, the certificate and the Matrix audit on every push (.github/workflows/quantum-clock.yml), and the Python validators and reference values (.github/workflows/validate.yml). The clock itself needs no dependencies: Node 22 and a browser are enough.

Global literaturesearched 18–19 October 2026

What exists, and what this adds

Every ingredient has a literature. I found no published construct that puts them together: a clock register defined by a pair of Casimir sectors of a spin tensor product; a leak-and-recovery cycle whose clicks are ticks; the matched-spectrum condition that keeps the logical phase exact through recovery, with the gap-24 obstruction that rules out the linear clock; and graphs of such clocks on worldlines, unravelled from stochastic ticks to a deterministic flow by the detection efficiency. So the tools here build it.

workwhat it shareswhat differs here
Zych, Costa, Pikovski, Brukner 2011 · Nat. Commun. 2, 505A quantum clock’s internal phase records proper time; which-path time dilation shows up as lost visibility.Proper time enters as a lapse on a whole Lindblad generator, per node of a network.
Pikovski, Zych, Costa, Brukner 2015 · Nat. Phys. 11, 668Time dilation couples internal energy, a clock, to the centre of mass and decoheres spatial superpositions.Here the clock itself is the protected system; its only dephasing comes from the recovery channel, and the matched clock removes that.
Castro-Ruiz, Giacomini, Brukner 2017 · PNAS 114, E2303Clocks become entangled through gravity, by mass–energy and time dilation.Clocks interact through QGNN graph Hamiltonians, scaled by edge lapses.
Smith, Ahmadi 2020 · Nat. Commun. 11, 5360Relational (Page–Wootters) clocks observe classical and quantum time dilation.A coordinate-time GKSL model with the time-chain identity, not a constraint formalism.
Kómár et al. 2014 · Nat. Phys. 10, 582A network of entangled clocks.Nodes are E47 clock-memory units on worldlines of an E47 pullback metric.
Kessler, Lovchinsky, Sushkov, Lukin 2014 · PRL 112, 150802; Dür et al. 2014 · PRL 112, 080801; Zhou, Zhang, Preskill, Jiang 2018 · Nat. Commun. 9, 78Error correction protects a phase being sensed; correction must not act on the signal.The signal is the clock itself. The obstruction is spectral: only Casimir gap 24 = 30 − 6 ticks at ω, so a linear clock can never be logical-blind to recovery; matching the syndrome sectors fixes it exactly.
Erker et al. 2017 · PRX 7, 031022; Woods, Silva, Pütz, Stupar, Renner 2022 · PRX Quantum 3, 010319Autonomous quantum clocks whose ticks are stochastic events; precision versus dimension and entropy.Ticks are recovery clicks with sub-Poissonian statistics F = 1 − 24c²γ²/(γ² + 8c²)², read beside a phase clock that does not need clicks at all.
Pearson et al. 2021 · PRX 11, 021029A measured clock: accuracy grows linearly with entropy per tick.This page is mathematics and simulation only; it measures nothing.
Arandes, Manikandan 2026 · arXiv:2609.16121Counting statistics of few-level clocks, including transients.Here: long-time and finite-time click statistics of a protected two-sector register.
Landi et al. 2024 · PRX Quantum 5, 020201Full counting statistics of open quantum systems.The tilted-generator method used here for the Fano factors.
Lidar 2014 (review); Zanardi, Rasetti 1997; Knill, Laflamme, Viola 2000Decoherence-free subspaces and noiseless subsystems under collective SU(2).E47 = 5V₂ ⊕ 2V₅ is selected by the Casimir, not by a noise algebra; the clock’s two states are one vector from each of its two Casimir sectors.
Verdon et al. 2019 · Quantum Graph Neural NetworksGraph-structured Hamiltonians as network layers; recurrent QGNNs learn Hamiltonian parameters.Temporal: each layer is a coordinate-time step with per-node lapses, and the learnable parameters include the lapses.
Formalism usedGitHub · Notion · Drive

The formalism, and where it lives

E0E47 = ker K = 5V2 ⊕ 2V5,  K = (C − 6I)(C − 30I),  Γ = I − K²/99144,  ‖Γⁿ − P‖ = (15/17)ⁿ
Canonical finite core · E47-Kartekeya
E0ρ(0) ⊂ E47, [H, P47] = 0 ⇒ ρ(t) ⊂ E47;  KρK† − ½{K†K, ρ} = 0;  gap 11664
Clock Math — First-Principles Lindblad Proof of Open-System Timekeeping and Protected Memory · Drive
E0U47φk = φk+1 mod 47,  ord U47 = 47,  ord(UΔ ⊗ U47) = 235;  ker(L ⊗ I + I ⊗ K²) = 1N ⊗ E47
Prime Clock and Synchronized Kernel Dynamics · Notion · the 47-cycle’s basis and phase origin are a declared choice, not canonical
E0zn+1 = zn² mod 5875: transient 2, period 220 = lcm(11, 20);  U = Γ ⊗ T,  U220 = Γ220 ⊗ I
MC-E47-MODSYNC-20261015-001 · validator on Drive
E0dτ = ψC dt ⇒ d/dτ = ψC⁻¹ d/dt;  dρ/dt = N(t) Lτ ρ
ARR-C005 · Time-Chain Identity (correction C0-TIME-CHAIN) · Notion · Drive
E0g = B4†(P6 − P0)B4 = diag(−1, 2, 8, 2),  N = √(1 − 2v₁² − 8v₂² − 2v₃²)
MC-E47-SPACETIME-PRIMA-FACIE-26-20260924 · canonical runner
E0H = f(C) + c(WV† + VW†),  R = √γ VW†;  q = 4c²/(γ² + 8c² + 4Δ²);  f = ωC/24 ⇒ ⟨O⟩ = cos ωτ
Time, Protected Memory, and E47: A Prima Facie Review · TQGNN reference (Python, 36/36)
E1The clock is a typed map from phase to a reproducible readout: base 60, 12 and 5 dialects of one phase
Clock-Based Mathematics · Drive presentation
E1Matrix receipts: SHA-256 over sorted-json-v1, 3 qubits, basis q0q1q2
THE MATRIX — Quantum Simulator · Notion · site app
Evidence boundary

What is established, and what is not

E0 proved
  • The clock-memory node is exactly four-dimensional inside the 125-dimensional carrier.
  • The matched clock keeps κ(τ) = e−iωτκ(0) under any leak and recovery; the linear clock cannot, because only (6, 30) has Casimir gap 24.
  • Lapse-scaled generators satisfy the time-chain identity; equal-lapse networks are the proper-time network run at rate N.
  • Orders 47 and 235; the 220-cycle and its synchronisation with Γ.
E1 computed
  • 48 checks in this browser, with residuals; JavaScript and Python agree to 10⁻¹⁴.
  • Receipts replay bit for bit with the Matrix’s own arithmetic.
E2 simulated
  • Monitored runs: click statistics agree with full counting statistics in a seeded Monte Carlo.
Open
  • A physical tick duration, a hardware clock, or any measurement. Nothing here is a device.
  • The bridge ω·Δτ per tick between phase and proper time is a declared convention.
  • A canonical basis, ordering or phase origin for the 47-cycle; SU(2)-covariant versus full 47-state clocks remains a design fork.
  • Which syndrome sectors a physical system would offer, and whether the matched condition f(42) = f(12) + ω can be engineered.
Personal Atlasthe vestibule of the City The Matrix Quantum Simulatorthree-qubit circuits and state receipts The Moment Ladderwhy the cube is the only carrier The Mathematical CityE47-Kartekeya runtime Source · Timethis clock, its tests and the TQGNN package