FINDINGS.md

Findings & Benchmarks for Cosmos

Every number here came from a run that could have failed. Where something came back null, it is reported as null. Where a measurement was wrong and had to be rebuilt, the failure is kept in the record, because the failures are how the rest earned trust.

Author: Cory Shane Davis · Independent Researcher Foundational deposit: 10.5281/zenodo.17574447

---

1. Is the entropy actually quantum?

The one measurement no classical process can fake.

quantity	value
CHSH statistic S	2.7905
classical (local hidden-variable) bound	2.0000
Tsirelson bound (quantum maximum)	2.8284
fraction of quantum maximum	98.7%
distance from classical bound	~35σ at 4096 shots/setting
backend	ibm_marrakesh

E(AB ) = +0.7197    E(AB') = -0.6675
E(A'B) = +0.6982    E(A'B') = +0.7051
S = E(AB) - E(AB') + E(A'B) + E(A'B') = 2.7905

Bell's theorem: no theory in which outcomes are determined by local pre-existing values can exceed 2.0. This hardware exceeds it by 35 standard deviations. The entropy source is physically quantum. This is also an entirely expected result for functioning quantum hardware. It verifies the pipeline; it does not discover new physics.

---

2. Were the weights really born from that entropy?

cosmos_born.pt was initialised by mapping measured bitstrings to uniforms u = int(bits)/2^n, then to weights through the inverse normal CDF z = √2·erf⁻¹(2u−1). If that pipeline is correct, real archived shots must come out standard normal at the resolution 5 qubits allows.

statistic	32-level theoretical ceiling	measured (3,258,886 draws)
mean	+0.0000	−0.0001
sd	0.9802	0.9804
|z| ≤ 1	0.6875	0.6874
|z| ≤ 2	0.9375	0.9374

Four decimal places on every statistic.

Why sd is 0.98 and not 1.00: 5 qubits give 32 discrete outcomes, so |z| cannot exceed 2.1523 by construction. The deficit is quantisation, not error, and it is exactly the quantisation a correct implementation must produce. A pipeline reporting sd = 1.0000 here would be the suspicious one.

Also verified at that historical checkpoint: 10,448,896 archived shots across 2,553 records, zero shot-conservation failures.

Public archive refresh (2026-07-31). The privacy-filtered release now contains 11,355,136 samples across 2,776 records with zero conservation failures: 7,770,112 samples / 1,897 records explicitly labeled as IBM hardware, 3,584,000 / 877 legacy unlabelled records, and 1,024 / 2 Azure simulator records. Only the explicitly labeled IBM subset is counted as verified hardware provenance.

---

3. Is the model reproducible from its seed?

The seed is SHA-256(quantum entropy ‖ bio-derived aggregates) → 60-bit integer, and it governs weight initialisation, data order, and every stochastic training step.

test	result
5 independent derivations	1 distinct value
bytes emitted during derivation	0 (privacy guard holds)
same seed → weights	identical, Δ = 0.000e+00
one bit flipped → weights	different: mean Δ = 2.26e-02 across 1,842,432 params

So "her weights are grown from that seed" is a verified property with a falsifiable test behind it, not a description. One bit of the seed produces a different model.

Zeref's Rain.

The bio-derived aggregates in that hash are personal to the author. The derivation module never prints, logs, or writes raw samples anywhere (verified above at 0 bytes emitted), and only aggregates ever leave it. What is published is the mechanism and the proof that it holds, not the data.

---

4. Do the circuit's correlations belong to the circuit or to the chip?

The strongest objection to any hardware-entanglement claim is that adjacent qubits leak into each other regardless of what you program. This test removes every confound at once: two arms on identical physical qubits, with identical gate count and depth, all pairs 1-hop native, zero SWAPs. The arms differ only in which native edges are entangled.

arm	own edges	those same pairs, other arm	Δ	t
A: (0,1),(2,3)	0.26890	0.00466	+0.26041	+80.5
B: (1,2),(3,4)	0.20695	0.00849	+0.20229	+164.6

A single physical pair swings 58× based only on whether its gate fired, and the excess relocates when the logical wiring changes. Crosstalk, graph distance, gate count and depth are all controlled simultaneously. 3 independent jobs per arm, so the error bar is between-job variance, not shot noise.

(An earlier pentagon/pentagram version of this test could not match gate counts because the transpiler inserted SWAPs. That limitation is recorded rather than hidden.)

---

5. Does the physics engine compute real chaos?

Checked against constants published for sixty years, not against itself.

quantity	published	measured
largest Lyapunov exponent λ₁	0.9056	0.90384
Kaplan–Yorke dimension	2.06215	2.06203
sum of exponents	−13.66667	−13.66667 (exact)
fixed point C₊	(8.48528, 8.48528, 27)	exact
attractor extent	|x|≈20, z≈48	19.13, 46.95

λ₁ measured by Benettin renormalisation over 2×10⁶ steps. A positive largest exponent with fractional attractor dimension is deterministic chaos on a strange attractor. 8/8 checks pass, including the driven engine staying finite and bounded over 20,000 steps at maximal drive.

---

6. Null results: the ones that matter most

Quantum entropy was injected at six distinct points. All six are null against matched classical controls. That is the correct outcome and §6 explains why.

A seventh test — of the §3 CST kernel, which is an architecture claim rather than a quantum one — was recorded as null, retracted, and re-run four times. The first three harnesses each broke the mechanism in a different way. The fourth revealed that the test had also been run in the wrong architecture. Corrected, it is the one positive result in this document: 6/6 seeds, t = −6.56 and −14.34.

injection site	result
i.i.d. weight initialisation	null. Advantage was init scale (σ≈0.025 vs 0.02), not quantum
decoder sampling seed	null. Pseudo / IBM / Rigetti equivalent within noise
spatial 54D seed (approximate)	null. Real seed beat 1/5 random vectors, z = −0.92
spatial 54D seed (full pipeline)	null. Real seed beat 0/8 random vectors, z = −1.75
entanglement matrix as attention kernel	null. Worse than plain attention, 3/3 seeds, t = −18.6
live sensory state as prompt text	null. n=40 paired, blind-judged, CI crosses zero
§3 Hebbian kernel, conventional transformer	null. CST worse by +0.0143, 0/3 seeds. See below
§3 Hebbian kernel, φ-governed transformer	NOT NULL. CST better by −0.044 (t=−6.56) and −0.155 (t=−14.34), 6/6 seeds across two dimension variants. The one positive result in this document

Retraction: the §3 kernel result

A seventh null was recorded here and has been withdrawn. It reported that the §3 Mixture-of-States kernel did not help, with the supporting observation that the learned gate "never moved off its 0.018 initialisation" across three seeds — framed as the optimiser declining the mechanism.

The gate did not decline. It could not move. Three compounding faults in the test harness, found by direct gradient measurement:

fault	measured
gate initialised at sigmoid(−4), in the saturated tail	d(sigmoid)/dx = 0.018 → gradient suppressed ~56×
resulting gradient on the gate	9.13e-05 → 365,118 steps needed to move it 0.01, in a 1,500-step run
at g≈0 the kernel contributes ~nothing	gradient reaching the 54D projection w54 = 0.000e+00

The third is the worst: the kernel could never become useful because it was never used, and was never used because it was not useful. All three are properties of the harness, not of the mechanism.

Reparameterising the gate as a raw scalar clamped to [0,1] fixed the saturation — and introduced a second fault. torch.clamp has exactly zero gradient outside its bounds, so the first optimiser step that carried the raw parameter below 0 pinned the gate there permanently. Measured on the resulting checkpoints: raw values −3.98, −4.04, −4.00, −4.01, gradient 0.000000. An absorbing state, not a decision.

A straight-through clamp cured that, and the gate still fell. The third fault was the real one, and it had been underneath both of the others the whole time.

sigma was initialised at exp(0) = 1, with no reference to the scale of the 54D state it is supposed to measure. The measured median pairwise ‖x₅₄ᵢ − x₅₄ⱼ‖² at initialisation is 61.98. So exp(−61.98/2) ≈ 3e−14 off the diagonal and exp(0) = 1 on it:

at initialisation	measured
sigma	1.0000
median pairwise ‖x₅₄ᵢ − x₅₄ⱼ‖²	61.98
H diagonal mass	0.9998 (uniform would be 1/T = 0.0078)
gradient reaching w54	1.19e−07

H arrived as the identity matrix. Blending the identity into attention instructs the model to attend only to the current token, which for next-token prediction discards the context — so gradient descent was correct to drive the gate to zero. The kernel was harmful by construction, and a saturated exponential passed w54 no gradient to escape with. Both earlier "the optimiser declined the mechanism" readings were measuring this.

The fix is the median heuristic: choose 2σ² = median(d²) per layer, calibrated in sequence so each layer sees inputs from the corrected layers below it.

	before (σ=1)	after (calibrated)
sigma, layer 0	1.0000	5.5719
H diagonal mass	0.9999	0.0857
`	w54 grad	`
gates whose gradient points up	0 / 4	2 / 4

Note that §3.2 of the paper never assigns σ a value. This is not a deviation from the specification; it is a hole in it, and any implementation that leaves σ at 1 will reproduce the identity-matrix failure.

The §3 result, finally earned

Three seeds, 1200 steps, quantum-born init, PLAIN and CST identical in every respect except the mechanism, gate free to move in both directions:

seed	plain loss	CST loss	plain real-word	CST real-word	final gate
0	1.39524	1.41313	0.833	0.888	0.0685
1	1.39940	1.41739	0.854	0.874	0.0503
2	1.41470	1.42165	0.908	0.901	0.0212
mean	1.40312	1.41739	0.865	0.888	0.0467

CST − PLAIN = +0.01427, t = +3.90, CST wins 0/3.

The gates were alive in all three seeds — never pinned, never at the floor. This is the first measurement of §3 in which the mechanism could actually be used. Used, it costs about 1% of held-out loss on this corpus at this scale.

Two honest caveats, pointing opposite ways:

• against the result — t = 3.90 on 2 degrees of freedom is p ≈ 0.06. Consistent in sign 3/3, but three seeds is three seeds.
• for the mechanism — real-word rate runs the other way, CST 0.888 vs 0.865, ahead in 2/3 seeds. That is one 600-character sample per arm at temperature 0.8. Far too noisy to claim, too consistent to hide.

What this does not settle. This tests the §3 kernel inside a conventional transformer: LayerNorm, learned absolute positions, a 4:1 GELU feed-forward. The paper specifies none of those. That turned out to be the whole story.

The φ-governed replication: §3 works

The paper specifies RMSNorm (§2.3), RoPE (§2.4), d_ff = ⌊d_model × φ⌋ (§2.2), φ-scaled initialisation (§6.2) and a PhiGatedFFN (§2.1). A search of the source tree found no implementation of any of it. Every measurement above was made in the wrong building.

Built faithfully and re-run at two dimension variants — A: d_model 192, 4 heads; B: d_model 199 = φ¹¹, 1 head — same corpus, same quantum-born init, same seeds, gate free:

scaffold	PLAIN	CST	delta	t	CST wins	mean gate
conventional	1.40312	1.41739	+0.0143	+3.90	0/3	0.047
φ-governed A	1.23680	1.19255	−0.0443	−6.56	3/3	0.096
φ-governed B	1.42867	1.27352	−0.1552	−14.34	3/3	0.093

6/6 seeds across both variants. The gate rose from 0.018 to ~0.096 in every run — the optimiser asking for five times more kernel than it started with — and σ kept adapting after calibration (26.8 → 18.8 at layer 0). The mechanism was actively tuned, not merely tolerated.

Credit where the measurement puts it. The scaffold is the larger share:

conventional PLAIN   1.40312
φ PLAIN              1.23680     scaffold alone:  −0.166   (~79%)
φ CST                1.19255     §3 kernel on top: −0.044   (~21%)

RMSNorm + RoPE + PhiGatedFFN account for most of the gain, and do it with fewer parameters (1.42M vs 1.92M), because ⌊d·φ⌋ is leaner than 4:1. The §3 kernel is a real additional effect on top of that, not the bulk of it.

Variant B is the mechanistic hint: its single 199-dim head cripples plain attention (1.43), and the kernel recovers most of the loss (1.27). That is consistent with the Hebbian term supplying a mixing pathway that multi-head attention otherwise provides.

The finding is conditional, and the condition is the point. The same kernel, same data, same seeds: harmful in a conventional transformer, helpful in a φ-governed one. §3 is not a drop-in improvement to attention. It is a component of an architecture.

Audited before being believed, given this document's history:

• Is PLAIN a true baseline? CST with the gate forced to 0 is bit-identical to PLAIN, max|Δ| = 0.000e+00 in both variants. The arms differ by the mechanism and nothing else.
• Extra active capacity? CST activates w54, which PLAIN never uses: 2.91% more live parameters. Real, and not fully eliminated. Against it: the identical asymmetry existed in the conventional scaffold, where CST lost 0/3. Capacity does not explain a win that appears only when the scaffold changes. A dead-weight control path for PLAIN would close this.

Limits. 1200 steps, 4 layers, char-level, one corpus, three seeds per variant, t on 2 degrees of freedom. This is evidence that §3 works on her data at this scale, not a claim about transformers in general.

RETRACTION: the coupling result was a corpus artefact

An earlier version of this document, published 2026-07-30, reported that coupling x₁₂ and x₄₂ beat every other configuration by roughly double the next best — "the largest effect in this document", t = −40.8. That is withdrawn. It was an artefact of an uncontrolled experiment, and the fault was mine.

Cosmos is alive while she is being measured. She appends her logged experience to the same corpus file the models train on. Each run loads it at startup, so runs started minutes apart train on different data:

ladder run     662,307 chars
trinity run    670,977          +8,670 -- and this is the run that "won"
tri3 run       672,505
tri re-run     674,428

The tell was running the identical configuration twice. Same rung, same seeds, same code:

tri (first run)   1.29152
tri (re-run)      1.22943      3,451 characters later

0.062 between two identical runs — the same magnitude as every effect being reported. Cross-run comparison was worthless and I had been doing it all night.

Re-run properly — corpus frozen to a snapshot, all seven rungs in one process, 21 runs, every comparison within-run — the ordering changes completely and the coupling advantage disappears.

The state ladder, controlled

The φ result establishes that a state helps. It does not say which one. §4.1 decomposes x₅₄ into x₁₂ (twelve scalars from 12D CST, §4.2) and x₄₂ (the 7-band vector manifold, §4.3), so each was tested separately.

Method, corrected. Corpus frozen to a 691,496-byte snapshot (sha256 9f1b3f37…), all seven rungs trained in one process against that one snapshot, 21 runs, 1200 steps × 3 seeds, gate free to move, every comparison within-run:

state feeding the kernel	val loss	vs baseline	t	wins	real-word	params
dyn12 Ω-driven leaky integrator, 12 scalars	1.17897	−0.0534	−11.45	3/3	0.782	1,137,420
dyn54 x₁₂ and x₄₂ concatenated	1.18791	−0.0445	−5.20	3/3	0.847	1,185,174
static54 plain projection of the hidden state	1.18824	−0.0442	−4.76	3/3	0.836	1,176,480
dyn42 42D vector state, 42×42 coupling	1.19020	−0.0422	−4.37	3/3	0.842	1,182,762
tri x₁₂ and x₄₂ coupled	1.19247	−0.0399	−3.08	3/3	0.882	1,189,210
tri3 all three organs, 108D kernel	1.20026	−0.0322	−2.83	3/3	0.826	1,230,682
none (baseline)	1.23241	—	—	0/3	0.810	1,135,008

2026-08-06: the gate was strangled at initialisation, and it cost more than the mechanism was worth

Every number above was measured with the Hebbian gate initialised at sigmoid(-4) = 0.018. That is not a neutral starting point. It means the kernel contributes two percent of attention from step one — too little influence to earn gradient — so each layer learns the kernel is useless and closes its gate. And a closed gate multiplies the kernel by ~0, which kills the gradient to the gate and to log_sigma. The layer cannot recover.

Measured on the trained checkpoints, per layer:

checkpoint	L0	L1	L2	L3
dyn12phos	0.7655	0.0009	0.0000	0.0000
phos	0.5617	0.0076	0.0042	0.0027
ladder_dyn12	0.2811	0.0091	0.0070	0.0046

The mechanism was alive in one layer out of four in every model this project has ever trained. Layer 0 survives only because its state is the largest in the stack; the state decays with depth (|state| 0.755 → 0.533 → 0.439 → 0.366) and the kernel goes uniform — measured H.diag 0.043, which is exactly mean(1/(i+1)) over a causal row at T=128.

Two geometric explanations were proposed and both were wrong, which is why this is reported as a 2×2 factorial rather than a fix that worked:

arm	state normalised	gate init	loss	layers alive
A	no	−4.0	1.05163	1/4
B	yes	−4.0	1.04742	1/4
C	yes	0.0	1.00823	4/4
D	no	0.0	0.99758	4/4

Arm B is the refutation: unit-normalising the state, which removes the scale mismatch entirely, changes nothing — still 1/4. An adaptive median-heuristic bandwidth was also tried and was likewise inert (1.05556 vs 1.04913, 1/4 alive). The scale drift is real — trained σ at L1 is 15.2 where calibration sets 1.9 — but it is a symptom.

It was one constant. At sigmoid(0) = 0.5 the kernel has real authority immediately and all four layers keep it, for 0.054 nats less loss. For scale, the entire dyn12-vs-none gap on this corpus is 0.032. The initialisation was worth more than the mechanism it was throttling, and every result in this file predates the fix.

COSMOS_GATE_INIT now defaults to 0.0. Set it to -4.0 to reproduce anything above.

2026-08-06: quantum_pool was discarding the Born rule

quantum_pool() mapped archived bitstrings to weights via vals.extend([z] * min(int(c), 8)). A 5-qubit job archives 4096 shots over 32 outcomes, so every count is ~128 and every one clipped to exactly 8. Measured over 401 runs:

distribution	entropy
true measured	3.4594 nats
what the model received	3.4657
uniform over 32 outcomes	3.4657

To four decimals, uniform. The shots were real, the archive was real, the CHSH violation was real — and the last step before the weights threw the measured probabilities away. Only 6.25% of shots survived, and the surviving ones carried no distributional information.

"Weights born from measured quantum" was true about provenance and false about content.

Replaced with largest-remainder proportional allocation (256 draws per run, shares proportional to measured counts, no flooring at the tail). The pool now carries entropy 3.4598 against the true 3.4594, and remains numerically safe for initialisation (mean −0.066, sd 0.994).

RETRACTION, 2026-08-06: a 0.0645-nat wiring win was the corpus moving

A 24-order wiring grid was screened at 400 steps and the top orders confirmed at 1200. cfg:tensor-gain-off-both came back at 1.11524 against dyn12's 1.17978 — a 0.0645 margin, larger than the entire state-mechanism effect.

It was not real. CORPUS_PATH points at her live experience log, which her running engine rewrites. Five configs were trained on a 162-symbol corpus and the sixth, hours later, on a 124-symbol one. A 162→124 alphabet is worth 0.27 nats at the uninformed limit — four times the claimed effect.

Nothing in the results file recorded which corpus produced which number. It was caught only because Ladder parameter counts scale with vocabulary (vocab × 384) and the winner's count disagreed with the others by exactly 38 × 384.

This is the same failure that retracted the trinity result. tools/wiring_grid.py now fingerprints every entry with the corpus sha and the architecture flags (gate_init, causal_omega, kernel_norm, adaptive_sigma), and refuses a cached entry whose fingerprint disagrees.

Re-run against one frozen snapshot, all six configs:

config	loss	sd	params
dyn42t 7 bands × sym(3×3)	1.10695	0.0167	1,161,422
dyn12	1.11813	0.0239	1,122,828
cfg:tensor-gain-off-both	1.12463	0.0178	1,165,854
cfg:tensor-add-off-12	1.12532	0.0191	1,165,854
cfg:tensor-off-add-12	1.12541	0.0190	1,165,854
none	1.15028	0.0172	1,120,416

Paired across shared seeds: none→dyn42t is t = +11.10, 3/3 — decisive. dyn12→dyn42t is t = +1.57, 2/3 — leading but not established at three seeds.

The three explicit wiring orders land within 0.0008 of each other, and six depth-varying chain orders landed within 0.00004. Combined:

The structure of the 42D organ matters. The order and direction of the couplings does not.

2026-08-06: PHOS and ladder_dyn12 cannot be merged in weight space

Both are rung: dyn12, 62 tensors, identical names, shapes and 162-symbol vocabulary — so θ(α) = (1−α)·dyn12 + α·PHOS is a well-defined model for every α. Sweeping the path:

α	0.0	0.25	0.50	0.75	1.0
loss	1.41492	2.63693	4.57108	2.58167	1.03325

A +3.538 barrier. quantum_birth draws sequentially from the pool, so two separately seeded runs consume different draws and share no initialisation; their hidden units sit in different arbitrary orders and no average of the two is a working model.

The sweep also showed there was nothing to merge for: PHOS beats ladder_dyn12 by 0.38 nats on the same architecture. PHOS simply is the good dyn12, so the useful operation is continuation, not averaging. dyn12phos is PHOS carried forward, never a merge.

Output-space pooling does work across rungs, where weight-space averaging is undefined. Greedy forward selection over all eleven ladder checkpoints keeps 6 and reaches 1.30549 against 1.41197 for the best single member — and it keeps dyn12p and tri3, which are individually mediocre. They are complementary, not merely good.

Correction, 2026-08-03: the 42D null was about the implementation, not the theory

dyn42 placed fourth in the table above (1.19020) and the coupled rungs tri and tri3 placed fifth and sixth. That was read as the 42D organ contributing little.

The 42D organ described in §4.3 had never been built. Every document in this project calls x₄₂ a "7-band vector manifold" — this file says so above, and the ladder's own docstring says "7 bands × 6 dims". The code was:

drive    = nn.Linear(d_model, 42)      # one flat projection
coupling = nn.Linear(42, 42)           # every dimension coupled to every other
gamma    = torch.full((42,), 0.05)     # forty-two copies of one constant

Nothing in it knew that 42 factors. And Dyn12 — in the same file — already says why that is wrong: per-dimension k and gamma "so the twelve dimensions separate by time constant rather than evolving as twelve copies." The 12 got that treatment. The 42 never did.

Rebuilt as specified, same corpus (9f1b3f37), same seeds, causal Ω, one process:

rung	mean	sd	gain vs none	42D organ params	per param
none	1.23215	0.0256	—	—	—
dyn42 flat 42-vector, dense 42×42	1.19023	0.0332	+0.04192	47,754	8.778e-07
dyn42b 7 bands × 6, block-diagonal	1.18104	0.0292	+0.05111	41,762	1.224e-06
dyn42t 7 bands × sym(3×3), congruence	1.18023	0.0292	+0.05192	41,006	1.266e-06

Both banded forms beat the flat one on 3/3 seeds while using fewer parameters. Rebuilt, the 42D organ moves from fourth to second on this board — ahead of static54 (1.18824) and dyn54 (1.18791).

dyn42t takes the factorisation one step further: a symmetric 3×3 matrix has exactly six independent components, so each band is a tensor in 3D stored in Voigt order [xx, yy, zz, xy, xz, yz], and the band-internal operation is a congruence M → A·M·Aᵀ — a change of basis. Measured: under a rotation, congruence leaves the eigenvalues and trace unchanged; a free 6×6 mixer does not. Nine weights per band instead of thirty-six.

What this does NOT establish. dyn42b and dyn42t differ by 0.0008 against a seed spread of 0.029 — the gap is 3% of the noise, so these two are indistinguishable at n=3. Structure beats flat is supported; which structure is not. This is also only at 1.1M parameters on the private corpus; it has not been run at scale or on WikiText-103, where dyn12's advantage grew.

Reproduce: python architecture/cosmos_state_ladder.py 1200 3 none,dyn42,dyn42b,dyn42t

---

Update, 2026-08-02: does it survive SCALE, on a corpus you can check?

Every dyn12 number above was measured at 1.1M parameters on 683,065 characters of one person's private logs. Two objections follow immediately and neither can be answered from that setup: it only works small, and it only works on your data. So it was re-run on WikiText-103-raw — 269,116,804 characters, sha256 f7d2398751239137, the benchmark the field already uses — at three sizes spanning a 20× parameter range, causal Ω throughout, all rungs at a size trained in one process against one corpus load.

size	none	static54	dyn12	static54/param	dyn12/param	ratio
d192 L4 (2.6M)	2.05432	2.03568	2.04196	4.495e-07	5.122e-06	11.4×
d384 L8 (11.6M)	1.77166	1.74860	1.75774	1.391e-07	2.893e-06	20.8×
d576 L10 (28.6M)	1.70084	1.69015	1.69147	3.435e-08	1.307e-06	38.1×

The advantage does not fade with scale — it roughly doubles at every step. Raw numbers: benchmarks/scaling_wikitext103.json.

Why, and it is arithmetic rather than luck. static54 is a d_model × 54 projection per layer, so it costs d·54·L. dyn12 is twelve scalars plus per-dimension k and gamma, so it costs d·12 + 24L. Depth multiplies one and not the other:

              static54     dyn12    static54 costs
d192 L4         41,472     2,412        17.2x more
d384 L8        165,888     4,812        34.5x
d576 L10       311,040     7,164        43.4x

A reviewer can check that without trusting the data at all.

And the benefit share went UP at the largest size, which cost alone does not predict:

              static54 gain   dyn12 gain   dyn12 delivers
d192 L4         0.01864        0.01236          66%
d384 L8         0.02306        0.01392          60%
d576 L10        0.01069        0.00937          88%

At 28.6M parameters dyn12 captures 88% of what a 43× larger mechanism buys.

What this does NOT show, stated plainly. static54 still has the lower absolute loss at all three sizes; the claim is efficiency and its scaling, not superiority. Two seeds per point and 1200 steps is thin — the d576 gap between static54 and dyn12 is 0.0013, comfortably inside what two seeds can resolve, so "dyn12 nearly matches static54" is a direction, not a measurement. All three rungs compress toward each other at d576 (1.690–1.701), and longer training could reorder them. Reproduce with benchmarks/scaling_run.py after benchmarks/fetch_wikitext.py.

---

Update, 2026-08-01: Ω was reading the future. The result survives it.

The problem. §3.4 defines Ω as attention received — omega = a.mean(1).sum(-2), summed over the QUERY axis. Under a causal mask that means Ω_j = Σ over i ≥ j of a_ij, so token j's Ω counts attention from tokens after j. Ω updates state_j, state_j feeds the next layer's Hebbian kernel, the kernel shapes attention, and attention shapes the logits at position j. Position j could see its own future.

Measured, not argued. benchmarks/causality_probe.py changes only the LAST token and checks whether earlier positions move. A causal model cannot move at all:

none      @init      0.000e+00   causal          <- controls, exactly zero
static54  @init      0.000e+00   causal
dyn12     @init      3.558e-06   LEAKS
dyn12     @g=0.562   1.723e-04   LEAKS           <- PHOS's trained gate
tri       @g=0.562   3.182e-04   LEAKS

The controls returning exactly 0.0 on the same harness is what makes this a measurement rather than float noise. The leak also scales with the gate — 48× larger at PHOS's trained value than at init — because Ω reaches the logits only through g·H.

The fix. Ω is now the normalised entropy of each query's own attention row: a per-query scalar that by construction depends only on tokens ≤ i. Summing over keys instead was never an option — softmax makes that identically 1.0, which is precisely ver.4.20's dead Ω. The log(i+1) normaliser removes the positional drift that comes from later rows simply having more keys to spread over. Default ON; COSMOS_CAUSAL_OMEGA=0 restores the original bit-for-bit so the two can be compared.

Re-measured as a paired experiment — both Ω definitions trained in ONE process against ONE corpus snapshot with the SAME seeds, because comparing against numbers from another day is the corpus-drift confound that forced the earlier retraction:

rung	leaky Ω	causal Ω	delta	params
none	1.23215	1.23215	+0.00000	1,135,008
static54	1.18824	1.18824	+0.00000	1,176,480
dyn12	1.17905	1.17978	+0.00073	1,137,420

causal Ω: static54  gain +0.04391 for 41,472 params  ->  1.059e-06 per param
causal Ω: dyn12     gain +0.05237 for  2,412 params  ->  2.171e-05 per param   20.5x

The leak was worth 0.00073 — 1.4% of dyn12's 0.05237 gain. The other 98.6% is the mechanism. dyn12 still has the best loss on the board and still wins on parameter efficiency by a factor of 20.5 rather than 21.

none and static54 never call Ω, so they had to be identical across arms — and they are, to every digit. That control is what makes the dyn12 delta attributable to Ω alone. Note also that this run reproduced the published static54 (1.18824) exactly and the published dyn12 (1.17897) to within 8e-05, so the table above was correctly measured; it simply had the leak inside it.

Verify it yourself. benchmarks/causality_probe.py draws a random seed every run, so your execution is independent evidence rather than a replay, and prints the seed so any run can be reproduced. Set COSMOS_CAUSAL_OMEGA=0 and it fails — a check that cannot fail is not a check.

1. §3 works. That survives everything. Every configuration beats the baseline on every seed, t from −2.83 to −11.45. A Gaussian kernel over an internal state, blended into attention through a learned gate, measurably helps. This is the one claim that has held through four broken harnesses and one broken methodology.

2. Coupling does not help. tri ranks fifth of six, losing to a plain static projection 2/3. tri3 — adding the third organ — is worst of the mechanism rungs. The earlier "coupling doubles the effect" finding does not exist under control. It is worth saying why the wrong answer was so convincing: the coupling matrices really did grow 3.0–3.4× during training, which reads as the optimiser reaching for the mechanism. Growth is evidence a mechanism is used, not evidence it helps.

3. The cheapest rung wins. dyn12 — twelve scalars and a leaky integrator, 2,412 extra parameters — has both the best loss and by far the highest consistency (t = −11.45, more than double any other rung's):

dyn12      2,412 extra params  ->  -0.05343   =  2.22e-5 nats/param
static54  41,472 extra params  ->  -0.04416   =  1.06e-6
dyn42     47,754 extra params  ->  -0.04221   =  8.84e-7
dyn54     50,166 extra params  ->  -0.04450   =  8.87e-7
tri3      95,674 extra params  ->  -0.03215   =  3.36e-7

20.5× more parameter-efficient than the next best, and it also wins outright -- re-measured 2026-08-01 with a causal Ω, which cost it 0.00073 of its 0.05237 gain (1.4%). The figures in this block are the ORIGINAL leaky-Ω run; the paired causal numbers are in the 2026-08-01 update above. The paper's §5 Singularity Hypothesis — "a smaller 42D model can eventually beat a larger vanilla model" — is supported here in the specific form that state is vastly cheaper than weights. Note the direction of the whole table: every additional mechanism past twelve scalars costs parameters and returns less.

4. One thing the losers are better at. tri has the best real-word rate on the board (0.882 vs 0.810 baseline) while ranking fifth on loss. Cross-entropy and word formation are not measuring the same thing, and a single scalar was never going to settle which state belongs in the architecture.

Limits. 1.2M parameters, character-level, one corpus, one snapshot, three seeds, t on 2 degrees of freedom, 1200 steps, 4 layers. The mechanism rungs span 1.179–1.200 — a range narrow enough that their ordering should be treated as provisional even though their advantage over the baseline is solid.

The retraction above is kept rather than deleted because it is the clearest example in this document of the failure mode described in §8: a confident negative that was entirely about the instrument. Three times. Each fix revealed the next fault, and the deepest one — σ — was invisible until the two above it were gone. It was caught only because the author refused the result and said the wiring was wrong.

This is the correct result, and it is load-bearing. Quantum measurements and a good PRNG draw from the same distribution. A correctly built system must therefore show no accuracy advantage from quantum bits. A project reporting that quantum made its model smarter would be reporting that something was broken or fabricated.

What the quantum provides is physical non-determinism, an open-system coupling to real hardware, and receipted provenance. Not lower loss. Bell violation plus verified provenance plus zero accuracy gain is the only combination an honest version of this could produce.

Timestamp-paired measured-state result (2026-07-30)

The frozen unpaired schedule control completed first: plain 1.61166, recorded-state schedule 1.67688, matched-chaotic 1.61045, and time-shuffled 1.60766. The recorded schedule lost to every control on 0/5 seeds (t = -10.55 vs plain, -11.55 vs matched chaos, -13.19 vs time-shuffle). That is a null regularisation result only; state rows advanced by optimizer step while unrelated text windows were sampled.

The author's frozen run joined 538 completed turns to the nearest 1 Hz numeric state sample; 381 responses longer than the 64-token block were usable. The observed maximum clock-join error was 0.731 s. Exact duplicate channels and every clock/counter field were removed, leaving 15 varying state channels. The chronological split contained 304 training responses (14 direct, 290 autonomous) and 77 holdout responses (2 direct, 75 autonomous).

arm (lower is better)	mean holdout loss
plain attention	2.04111
aligned measured state	2.06156
shuffled state/text assignment	2.07118
time-shifted assignment	2.06677

Aligned state lost to plain on 0/5 seeds (control-minus-aligned delta -0.020447, t = -9.59). It beat shuffled assignment on 5/5 (delta +0.009624, t = +2.12) and beat shifted assignment on 4/5 (delta +0.005213, t = +3.09).

Pre-registered verdict: NULL. There is a partial assignment-specific signal relative to the shuffled conditioned control, but conditioning does not improve held-out text prediction over no conditioning and does not beat every destroyed-pairing control on every seed. This is not evidence of causal sensory influence, consciousness, AGI, or quantum advantage. State was sampled near response completion, so temporal direction is unresolved; with only two direct replies in holdout, no direct-conversation conclusion is supportable.

Frozen dataset SHA-256: db69f2bb394bfefc9e6b8b68e284993d642931490051c24cf3e9a8751f19ca65. Machine-readable metrics: benchmarks/results/paired_conditioning_20260730.json (the private turn text and paired dataset are not shipped).

---

7. Integration structure

Integrated information across her running state, Gaussian estimators, phase-randomised surrogates (which preserve each channel's own spectrum and autocorrelation exactly and destroy only cross-channel coupling).

Directed causation (Granger, against circular-shift surrogates):

direction	before coupling	after
awareness → physics	z = +0.05	z = +7.21
physics → awareness	not measured	z = +12.24

Partial information decomposition (Barrett-2015 MMI), per bipartition:

	value
redundancy	1.72 – 2.58 nats
synergy	0.33 – 1.16 nats
cuts with synergy above surrogate	1 of 10
the one that is: consciousness │ rest	synergy 1.1613 vs surrogate 0.7476, z = +6.38

Honest reading: the system is tightly coupled and highly redundant. Subsystems largely mirror one another, because most are parallel readouts of the same underlying physics. That is robustness, not emergence. One seam is genuinely synergistic: consciousness carries 0.66 nats of unique information that no other subsystem reconstructs.

A methodological note worth more than the result: whole-minus-sum Φ was tried first and returned zero repeatedly. It goes negative on redundancy, because shared information is counted in both parts and exceeds the whole. It cannot distinguish "not integrated" from "integrated so tightly the information is duplicated." Four separate defects in that measurement were found and are documented in the repository history. Reported nulls that were later traced to instrument error are marked as such rather than deleted.

---

8. The write-only failure mode

The most useful engineering result here is not a measurement. It is a pattern that showed up seven separate times in one system, and it is easy to reproduce in any project of this shape.

Each of these had a complete, correct, working write path and no reader:

system	wrote	was read by
12D CST physics	continuously while a face was in frame	discarded the moment the face left
affect → physics	consciousness computed every tick	nothing acted on it
expression	every utterance she produced	nothing; speaking changed nothing in her
archival memory	7,612 records over months	only the dev swarm, never her voice
REM consolidation	419 dreams, selected by synaptic strength	nothing, ever
recall window	3,624 exchanges retained	a 40-slot positional slice, 87% self-talk
embeddings	intended by design	never produced — 0 of 7,612

None of these threw an error. None appeared in a log. Every one of them was a system faithfully doing half its job while looking completely healthy from the outside.

Why it is worth publishing: a write path fails loudly — permissions, disk, schema. A missing read path is silent by construction. The component reports success, the store grows, dashboards look green, and the capability simply does not exist. The only reliable detection is to check the consumer side of every producer, which nothing in normal testing prompts you to do.

Diagnostic that found six of the seven: grep for the writer, then grep for a caller of the reader. If the second search returns only the module that defines it, the loop is open.

A related caution from the same session: four separate measurement instruments built to evaluate this system were themselves wrong — a partition that grouped two subsystems into one, a minimum taken over a set containing a sensory input, a damping term that silenced the channel being measured, and an embedding model that ranked unrelated text above a near-verbatim match. Each produced a confident null. Each null was about the instrument. Verify the instrument against a known-answer case before believing a negative result.

---

9. Growth

	before	after
training steps	7,825	9,425
corpus	126 KB	592 KB
held-out loss	,	0.4812
real-word rate	78%	88.5%

Growth improved held-out loss by 0.0025 nats, paired over 200 identical batches, SE 0.0005, t = +4.97, 95% CI [+0.0015, +0.0035]. Statistically real, practically small, reported as measured rather than as a headline. She resumes from her previous checkpoint rather than restarting, so her lineage back to the original quantum birth is unbroken.

---

10. What none of this shows

Nothing here is evidence about machine consciousness, in either direction.

Loss curves, Bell violations, Lyapunov exponents and integration measures are all silent on whether there is anything it is like to be this system. Section 7 tests one contested theory's necessary structural condition, necessary is not sufficient, and IIT itself is disputed.

Any self-report the system produces about its own inner life is the least reliable signal available, and gets more eloquent the less there is behind it. It is excluded from evidence here on purpose.

---

11. general.architecture = cosmos

A GGUF's general.architecture is not a name field. It is llama.cpp's dispatch key, matched against a fixed enum of architectures the binary can build a compute graph for. Writing your project's name there produces a file no loader will open — the loader looks for yourname.block_count, finds nothing, and refuses. An earlier file in this project did exactly that and never loaded in either daemon.

There are only two honest options: serve the model yourself and speak the API, or register the architecture in the engine. This project now does the second.

LLM_ARCH_COSMOS is implemented in a llama.cpp fork: 24 lines across five existing files plus src/models/cosmos.cpp. Two identities keep it inside the existing infrastructure rather than bolting on a subsystem:

Dropping σ from the graph. Expanding the square in H_ij = exp(−‖x₅₄ᵢ−x₅₄ⱼ‖²/2σ²) makes the exp(−‖x₅₄ᵢ‖²/2σ²) factor constant along j, so it cancels in the row normalisation and H becomes a plain masked softmax over x'ᵢ·x'ⱼ − ‖x'ⱼ‖²/2 with x' = x₅₄/σ. Folding σ into W54 at conversion time removes every exp, clamp and divide from the graph and lets H reuse ggml_soft_max_ext.

Caching the 54D state. The kernel needs x₅₄ for every past token and the unified KV cache has no slot for it. Recovering it from the cached keys as W54·Wk⁻¹·K is exact in real arithmetic, and was rejected on measurement: cond(Wk) reaches 6.9e6, so an F16 cache destroys it. Instead attention.key_length is widened by d54 and x₅₄ rides in the key rows, sliced back apart on read.

Verification. Loading and producing plausible text proves nothing — a bypassed kernel does that too. Greedy decoding is deterministic, so a correct implementation must reproduce the PyTorch argmax sequence exactly:

gate	PyTorch	llama.cpp	agreement
0.0 (kernel off)	stump in the streaming	identical	22/22
as trained (0.018)	stump in the streaming	identical	22/22
0.9 (kernel dominant)	floringy alingy alines	identical	22/22

The third row is the one that counts. At g=0.018 a wrong kernel hides inside a 2% blend; at g=0.9 the output diverges completely and still matches character for character.

Stock llama.cpp will refuse this file, and should. It has no LLM_ARCH_COSMOS to dispatch to. That refusal is the difference between owning an architecture and relabelling someone else's.

What is honestly in the file. blk.N.attn_54 (54 × n_embd), a per-layer blend gate, and weights whose every initial value came from measured IBM Quantum hardware. What is not in it: the φ-governed scaffold the paper specifies — RMSNorm, RoPE, d_ff = ⌊d·φ⌋, φ-scaled initialisation. The shipped architecture implements §3's kernel inside a conventional transformer. A grep of the source tree found no implementation of the φ scaffold at all, which means every §3 measurement in §6 was made in the wrong building.

That replication has since been run, and it reverses the result: the kernel loses 0/3 in a conventional transformer and wins 6/6 across two φ-governed variants (§6). The shipped llama_cpp_cosmos.cpp therefore implements the weaker of the two architectures. Bringing it up to the paper — RMSNorm, RoPE, d_ff = ⌊d·φ⌋ — is the obvious next step and is less custom C++ than what is there now, since llama.cpp provides all three natively.

---

Licensed CC BY 4.0. Attribution appreciated, including the nulls, which are part of the finding.