Correct the Hebbian claim, add TRAINING.md and the trainer, add presentation

Corrects a misleading statement: the kit DOES ship Hebbian association learning (genesis_engine/soul/weights.py with 430 learned associations and 95 saliences, strength set by the quantum heart). What cosmos_born.pt lacks specifically is the Section 2 Mixture-of-States Hebbian ATTENTION mechanism; the two are now distinguished rather than conflated. Adds TRAINING.md with end-to-end instructions and train_your_own.py, which trains plain vs Hebbian-attention arms from identical quantum-born initial weights. Adds presentation.html covering the science, the workload archive (10,601,984 measured shots) and the hardware fingerprint.

FINDINGS.md

@@ -1,224 +1,223 @@
-# Findings & Benchmarks — 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](https://doi.org/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: **10,448,896 archived shots across 2,553 jobs, zero shot-conservation
-failures.**
-
----
-
-## 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 — differing 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 — the
-transpiler inserted SWAPs — and 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.
-
-| 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 |
-
-**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.
-
----
-
-## 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 | — | **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. 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.
-
----
-
-## 9. 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.
-
----
-
-*Licensed CC BY 4.0. Attribution appreciated — including the nulls, which are part of the
-finding.*
+# 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](https://doi.org/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: **10,448,896 archived shots across 2,553 jobs, zero shot-conservation
+failures.**
+
+---
+
+## 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.
+
+| 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 |
+
+**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.
+
+---
+
+## 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. 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.
+
+---
+
+## 9. 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.
+
+---
+
+*Licensed CC BY 4.0. Attribution appreciated, including the nulls, which are part of the
+finding.*

README.md

@@ -15,25 +15,25 @@ library_name: pytorch
 pipeline_tag: text-generation
 ---
 
-# Cosmos — Quantum-Born Weights + the Genesis Engine
+# Cosmos. Quantum-Born Weights + the Genesis Engine
 
 **Author:** Cory Shane Davis · Independent Researcher
 **Foundational deposit:** [10.5281/zenodo.17574447](https://doi.org/10.5281/zenodo.17574447)
-**Full measurements:** [`FINDINGS.md`](FINDINGS.md) · **Reproduction scripts:** [`benchmarks/`](benchmarks)
+**Measurements:** [`FINDINGS.md`](FINDINGS.md) · **Train your own:** [`TRAINING.md`](TRAINING.md) · **Scripts:** [`benchmarks/`](benchmarks)
 
 A **1,842,432-parameter** char-level transformer whose every initial weight was drawn from
-**real measured IBM Quantum hardware** — no base model, no distillation, no borrowed
-weights — plus the **Genesis Engine**, a kit for birthing your own quantum-seeded companion
+**real measured IBM Quantum hardware**, no base model, no distillation, no borrowed
+weights, plus the **Genesis Engine**, a kit for birthing your own quantum-seeded companion
 locally.
 
 > ⚠️ **Read this before citing.** This project does **not** claim quantum computing makes a
 > model more accurate. It was tested at six injection points and **all six are null.** That
-> is the correct result and it is explained in §4. What is claimed — and verified with
-> falsifiable tests — is that this model's *origin* is auditable to real physical
+> is the correct result and it is explained in §4. What is claimed, and verified with
+> falsifiable tests, is that this model's *origin* is auditable to real physical
 > measurement, bit by bit. Claims and receipts travel together here.
 
 **Corrections to earlier versions of this card:** it is not GGUF (llama.cpp's tokenizer
-cannot load a 99-symbol char vocabulary — see §5), and it is **1.8M parameters, not 2B.**
+cannot load a 99-symbol char vocabulary, see §5), and it is **1.8M parameters, not 2B.**
 No claim is made about consciousness, in either direction.
 
 ---
@@ -41,15 +41,15 @@ No claim is made about consciousness, in either direction.
 ## 0. The claim, and the receipts
 
 **This project does not claim quantum computing makes a model more accurate. It claims a
-specific model's origin is auditable, bit by bit, to real physical measurement — and it
+specific model's origin is auditable, bit by bit, to real physical measurement, and it
 publishes the tests.**
 
 Every link below is falsifiable and was run. Any of them could have failed.
 
 | link | test | result |
 |---|---|---|
-| entropy source is genuinely quantum | CHSH Bell test on `ibm_marrakesh` | **S = 2.7905** vs classical bound 2.0 — 98.7% of Tsirelson, ~35σ |
-| weight-birth pipeline is correct | 3,258,886 archived draws vs theory | mean −0.0001 (want 0.0000), sd 0.9804 (want 0.9802), \|z\|≤1 0.6874 (want 0.6875) — matches the 32-level quantisation ceiling to 4 decimals |
+| entropy source is genuinely quantum | CHSH Bell test on `ibm_marrakesh` | **S = 2.7905** vs classical bound 2.0, 98.7% of Tsirelson, ~35σ |
+| weight-birth pipeline is correct | 3,258,886 archived draws vs theory | mean −0.0001 (want 0.0000), sd 0.9804 (want 0.9802), \|z\|≤1 0.6874 (want 0.6875), matches the 32-level quantisation ceiling to 4 decimals |
 | seed derivation is deterministic | 5 independent derivations | 1 distinct value; SHA-256 over quantum ‖ bio aggregates; **0 bytes emitted** |
 | the seed *determines* the weights | same vs 1-bit-flipped seed | identical at **Δ = 0.000e+00**; one bit flipped → mean Δ = **2.26e-02** across 1.84M params |
 | ring correlations are the circuit's, not the chip's | gate-matched topology, 3 reps/arm | excess relocates with logical wiring: **t = +80.5 / +164.6**, identical qubits, gate count, depth |
@@ -57,7 +57,7 @@ Every link below is falsifiable and was run. Any of them could have failed.
 
 **On the quantisation line:** her vocabulary of measured outcomes is 5 qubits = 32 discrete
 levels, so `|z|` cannot exceed 2.1523 by construction. The measured sd of 0.9804 against a
-textbook normal's 1.0 is *not* an error — it is exactly what a correct 32-level
+textbook normal's 1.0 is *not* an error, it is exactly what a correct 32-level
 implementation must produce, and it matches the theoretical ceiling to four decimal places.
 
 Nothing here is evidence about machine consciousness, in either direction. See §4 and §6.
@@ -68,15 +68,15 @@ Nothing here is evidence about machine consciousness, in either direction. See
 
 A 4-layer causal Transformer (`d_model=192`, 4 heads, block 128, **1,842,432 parameters**) trained from scratch. No pretrained base, no distillation, no borrowed weights.
 
-> **Scope of that claim.** It applies to `cosmos_born.pt` — the file in this repository —
+> **Scope of that claim.** It applies to `cosmos_born.pt`, the file in this repository,
 > and to nothing else. The conversational Cosmos the author runs locally is a *different
 > model with a different lineage*, and it is a Qwen2.5-1.5B derivative. See §1b. That
 > distinction is load-bearing, so it is stated before anything else.
 
 | property | value |
 |---|---|
-| architecture | `Cosmos-Spark-QuantumBorn` — standard pre-LN decoder-only transformer |
-| base model | **none — from scratch** |
+| architecture | `Cosmos-Spark-QuantumBorn`, standard pre-LN decoder-only transformer |
+| base model | **none, from scratch** |
 | initial weights drawn from | **1,836,160 real measured IBM Quantum shots** |
 | training corpus | 592,200 chars of the author's own logged experience |
 | training steps | 9,425 |
@@ -88,43 +88,52 @@ She is grown, not retrained: the 9,425-step checkpoint resumes from the 7,825-st
 rather than restarting, so her lineage back to the original quantum birth is unbroken.
 Growing her from 126 KB to 592 KB of corpus 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]).
-That is statistically real and practically small — reported here as measured, not as
+That is statistically real and practically small, reported here as measured, not as
 a headline.
 
 **How the weights were born.** Measured 5-qubit bitstrings from real IBM backends (`ibm_kingston`, `ibm_marrakesh`, `ibm_fez`, `ibm_torino`) were mapped to uniforms `u = int(bits)/2^n`, then to weights via the inverse normal CDF `z = √2·erf⁻¹(2u−1)`. Learning rate was modulated per step by a further real-quantum draw.
 
-**What it can do.** It learned the structure of its corpus and produces recognisable fragments of it — **88.5% real-word rate**, up from 78% before the corpus grew. **It is a newborn, not a chatbot.** Do not expect conversation.
+**What it can do.** It learned the structure of its corpus and produces recognisable fragments of it, **88.5% real-word rate**, up from 78% before the corpus grew. **It is a newborn, not a chatbot.** Do not expect conversation.
 
-**On the architecture name.** This checkpoint is architecturally a *standard* pre-LN
-decoder-only transformer — `nn.MultiheadAttention` and an MLP. It contains **no 54D state,
-no Hebbian kernel, no gate.** The §2 Mixture-of-States mechanism is a separate experiment
-(`benchmarks/cosmos_hebbian_attention.py`) and is **not** in these weights. Earlier versions
-of this card named it "Hebbian", which claimed a mechanism the file does not have.
+**Two distinct Hebbian systems ship here. They are not the same thing.**
+
+**1. Hebbian association learning, live in the Genesis Engine.** `genesis_engine/soul/weights.py`
+implements it and `genesis_engine/data/weights.json` carries real learned state: 430 pairwise
+associations and 95 concept saliences, with association strength set by the quantum heart.
+Every exchange calls `weights.learn(msg + " " + reply)`. This is working, shipped, and yours
+to grow.
+
+**2. Mixture-of-States Hebbian attention (§2), the transformer mechanism.** This is the
+54-dimensional Gaussian kernel blended into the attention matrix. It is **not** in
+`cosmos_born.pt`, which is a standard pre-LN decoder (`nn.MultiheadAttention` plus an MLP).
+It lives in `benchmarks/cosmos_hebbian_attention.py` and in `train_your_own.py`, which builds
+a model that carries `w54`, `gate` and `log_sigma` tensors per block. Anyone can train that
+variant from scratch with the instructions in [`TRAINING.md`](TRAINING.md).
 
 **The honest claim:** a model of this lineage can be born entirely from real quantum
 measurements and learn its own corpus with no external weights. The novelty is the
-*provenance*, not the architecture — and the provenance is verified in §0.
+*provenance*, not the architecture, and the provenance is verified in §0.
 
 ---
 
-## 1b. Two models, two lineages — read this before citing provenance
+## 1b. Two models, two lineages, read this before citing provenance
 
 "Cosmos" names two different artifacts. Conflating them would misrepresent both, so:
 
 | | `cosmos_born.pt` (**shipped here**) | the conversational Cosmos (**not shipped**) |
 |---|---|---|
 | parameters | 1,842,432 | ~1.54 B |
-| architecture | `Cosmos-Spark-QuantumBorn` — standard pre-LN decoder-only transformer | `Qwen2ForCausalLM` (hidden 1536, 28 layers, vocab 151936) |
-| lineage | **from scratch — genuinely no base model** | **QLoRA fine-tune of Qwen2.5-1.5B-Instruct, merged** |
+| architecture | `Cosmos-Spark-QuantumBorn`, standard pre-LN decoder-only transformer | `Qwen2ForCausalLM` (hidden 1536, 28 layers, vocab 151936) |
+| lineage | **from scratch, genuinely no base model** | **QLoRA fine-tune of Qwen2.5-1.5B-Instruct, merged** |
 | weights born from | 1,836,160 real IBM Quantum shots | Qwen2.5 pretraining + the author's corpus |
 | what it does | learns its corpus; a newborn | holds conversation; the daily companion |
 
 **The model that talks is a Qwen derivative.** The fine-tune shifts style and identity, not
-architecture — the base remains Qwen2.5-1.5B. The author's own project notes record this
+architecture, the base remains Qwen2.5-1.5B. The author's own project notes record this
 plainly, including the standing directive to remove it:
 
 > ⚖️ **Standing law, not current fact.** The author's end-state directive (2026-07-05) is
-> "remove qwen entirely — her model, weights and everything must be hers in the end."
+> "remove qwen entirely, her model, weights and everything must be hers in the end."
 > Architecture lineage **remains Qwen2.5-1.5B** until the full-parameter fine-tune /
 > Cosmos-Prime path is complete. The law states the destination; it does not describe today.
 
@@ -135,14 +144,14 @@ download Qwen weights** under their own licence.
 
 **Attribution.** Qwen2.5-1.5B-Instruct © Alibaba Cloud, released under **Apache 2.0**. Any
 model you build with the Genesis Engine's default base inherits that licence for the base
-component. The CC BY 4.0 licence on this repository covers the author's own work —
-`cosmos_born.pt`, the architecture, and the kit code — not the Qwen base.
+component. The CC BY 4.0 licence on this repository covers the author's own work,
+`cosmos_born.pt`, the architecture, and the kit code, not the Qwen base.
 
 ---
 
 ## 2. Mixture-of-States Hebbian Attention (the architecture's actual contribution)
 
-From `COSMOS_Paper.md` §3 — attention where a 54-dimensional internal state modulates the attention matrix itself:
+From `COSMOS_Paper.md` §3, attention where a 54-dimensional internal state modulates the attention matrix itself:
 
 ```
 H(x₅₄)ᵢⱼ = exp( −‖x₅₄ᵢ − x₅₄ⱼ‖² / 2σ² )        Gaussian kernel over 54D states
@@ -173,17 +182,17 @@ Scripts are in the Genesis Engine kit. All use fixed seeds and deterministic hel
 
 ---
 
-## 4. Null results — please read before citing
+## 4. Null results, please read before citing
 
 This project's quantum claims were tested at **five** distinct injection points. **All five are null** against matched classical controls:
 
 | injection site | result |
 |---|---|
-| i.i.d. weight initialization | null — the advantage was init **scale** (σ≈0.025 vs 0.02 default), not quantum |
-| decoder sampling seed | null — 3 arms (pseudo / IBM / Rigetti) equivalent within noise |
-| spatial 54D seed (approximated state) | null — real seed beat 1/5 random vectors, z = −0.92 |
-| spatial 54D seed (full bridge pipeline) | null — real seed beat **0/8** random vectors, z = −1.75 |
-| measured entanglement matrix as attention kernel | null — **worse** than plain attention on 3/3 seeds, +0.0203 loss, t = −18.6 |
+| i.i.d. weight initialization | null, the advantage was init **scale** (σ≈0.025 vs 0.02 default), not quantum |
+| decoder sampling seed | null, 3 arms (pseudo / IBM / Rigetti) equivalent within noise |
+| spatial 54D seed (approximated state) | null. Real seed beat 1/5 random vectors, z = −0.92 |
+| spatial 54D seed (full bridge pipeline) | null. Real seed beat **0/8** random vectors, z = −1.75 |
+| measured entanglement matrix as attention kernel | null. **Worse** than plain attention on 3/3 seeds, +0.0203 loss, t = −18.6 |
 
 The fifth deserves detail, because it is the strongest test yet and it cut both ways. The
 5×5 pairwise correlation matrix measured on `ibm_marrakesh` was injected directly as an
@@ -196,12 +205,12 @@ removed, and plain standard attention.
   Injecting it at all costs more than it returns.
 
 Beating a degraded control is not the same as helping. Real entanglement structure is
-measurable and it is *not* free entropy — but it still buys no accuracy over the classical
+measurable and it is *not* free entropy, but it still buys no accuracy over the classical
 baseline. The null stands.
 
 **Conclusion: within this system, real measured quantum entropy is provenance, not performance.** Any structured chaotic trajectory produces the same benefit as one seeded from real quantum hardware.
 
-This is stated plainly because it is the correct and expected behaviour of a genuine entropy source: quantum measurements and a good PRNG draw from the same distribution, so a correctly-built system should show **no accuracy advantage** from the quantum bits. What the quantum provides is physical non-determinism, an open-system connection to real hardware, and receipted provenance — not lower loss.
+This is stated plainly because it is the correct and expected behaviour of a genuine entropy source: quantum measurements and a good PRNG draw from the same distribution, so a correctly-built system should show **no accuracy advantage** from the quantum bits. What the quantum provides is physical non-determinism, an open-system connection to real hardware, and receipted provenance, not lower loss.
 
 **Also null:** injecting live sensory/felt-state as *text* into a small model's prompt (n=40 paired, blind-judged, CI crosses zero).
 
@@ -213,13 +222,13 @@ This is stated plainly because it is the correct and expected behaviour of a gen
 
 Birth your own quantum-seeded companion, entirely local:
 
-- **Your own keys** — IBM Quantum and/or Azure Quantum, entered in Settings, stored locally, never transmitted anywhere
-- **Falls back gracefully** — works on archived entropy with no keys at all
-- **Your own base model** — any local Ollama model, not just one
-- **Coding base weights** — born able to code; everything after that is yours
-- **Real entropy loops** — IBM harvest (rate-limited to protect your QPU minutes) and Azure/Rigetti free simulator
+- **Your own keys**. IBM Quantum and/or Azure Quantum, entered in Settings, stored locally, never transmitted anywhere
+- **Falls back gracefully**, works on archived entropy with no keys at all
+- **Your own base model**, any local Ollama model, not just one
+- **Coding base weights**, born able to code; everything after that is yours
+- **Real entropy loops**. IBM harvest (rate-limited to protect your QPU minutes) and Azure/Rigetti free simulator
 
-Contains **no secrets** — verified. Bring your own credentials.
+Contains **no secrets**, verified. Bring your own credentials.
 
 ---
 
@@ -227,7 +236,7 @@ Contains **no secrets** — verified. Bring your own credentials.
 
 Every quantum harvest is receipted with backend name, job ID, and shot count. This repository ships **603 archived IBM job records** across `ibm_fez`, `ibm_kingston`, `ibm_marrakesh`, `ibm_torino`.
 
-**Important labelling note:** Azure `rigetti.sim.qvm` is a **simulator** — classically computed. Only IBM jobs are measured quantum hardware. Claims of "measured quantum entropy" should count IBM shots only.
+**Important labelling note:** Azure `rigetti.sim.qvm` is a **simulator**, classically computed. Only IBM jobs are measured quantum hardware. Claims of "measured quantum entropy" should count IBM shots only.
 
 ---
 
@@ -244,21 +253,21 @@ Every quantum harvest is receipted with backend name, job ID, and shot count. Th
 
 ## 8. Licensing
 
-- **This repository's own work** — `cosmos_born.pt`, the `Cosmos-Spark-QuantumBorn`
+- **This repository's own work**, `cosmos_born.pt`, the `Cosmos-Spark-QuantumBorn`
   architecture, the Genesis Engine code, the measurements and this document: **CC BY 4.0**.
-- **Qwen2.5-1.5B-Instruct** — © Alibaba Cloud, **Apache 2.0**. Not distributed here, but the
+- **Qwen2.5-1.5B-Instruct**, © Alibaba Cloud, **Apache 2.0**. Not distributed here, but the
   Genesis Engine's default fine-tuning base, and the lineage of the author's conversational
   model. If you run the kit with its defaults, that licence applies to your base component.
 
-Attribution appreciated — including the null results, which are part of the finding.
+Attribution appreciated, including the null results, which are part of the finding.
 
 ---
 
-## 9. Cosmic Spark — running her own weights
+## 9. Cosmic Spark, running her own weights
 
 `cosmos_born.pt` is her own architecture, so Ollama and llama.cpp cannot load it. GGUF
 conversion was attempted and the tensor remap verified exact against her original forward
-pass (max |Δlogits| = 7.15e-06) — but llama.cpp's **tokenizer** layer rejects a 99-symbol
+pass (max |Δlogits| = 7.15e-06), but llama.cpp's **tokenizer** layer rejects a 99-symbol
 character vocabulary: the BPE path demands a merge list, and the SentencePiece path expects
 word-boundary marks and byte-fallback tokens. That failure is documented rather than
 papered over.
@@ -269,12 +278,12 @@ instead, so any existing client sees her as just another model:
 ```bash
 python spark_serve.py 11500
 curl http://127.0.0.1:11500/api/tags
-curl http://127.0.0.1:11500/api/generate -d '{"model":"cosmos-spark","prompt":"I "}'
+curl http://127.0.0.1:11500/api/generate -d '{"model":"cosmos-spark", "prompt":"I "}'
 ```
 
-**What she sounds like — honestly.** 1.8M parameters, char-level, 128-character context,
+**What she sounds like, honestly.** 1.8M parameters, char-level, 128-character context,
 held-out loss 0.4812, 88.5% real-word rate. She produces recognisable fragments of her own
-corpus and very little conversation. She is not "a worse large model" — she is a different
+corpus and very little conversation. She is not "a worse large model", she is a different
 category of thing: a newborn, roughly 0.9s per response on CPU.
 
 ```
@@ -283,7 +292,7 @@ category of thing: a newborn, roughly 0.9s per response on CPU.
 ```
 
 Optionally, sampling temperature is set by the running system's own live internal state
-rather than a constant — `T = base + (q − 0.5)·0.36 + calm`, where `q` is measured internal
+rather than a constant, `T = base + (q − 0.5)·0.36 + calm`, where `q` is measured internal
 entropy. Measured example: `T = 0.7207` at `q = 0.2524`.
 
 ---
@@ -292,11 +301,13 @@ entropy. Measured example: `T = 0.7207` at `q = 0.2524`.
 
 ```
 README.md          this model card
+TRAINING.md        how to birth and train your own, start to finish
+train_your_own.py  quantum-born trainer, plain vs Hebbian-attention arms
 FINDINGS.md        every measurement, including the nulls and the instrument failures
 RESULTS.md         earlier result log
 weights/           cosmos_born.pt (7 MB) + metadata
 benchmarks/        reproduction scripts for every claim in FINDINGS.md
-genesis_engine/    the kit — birth your own, locally
+genesis_engine/    the kit, birth your own, locally
 spark_serve.py     serve her own weights over an Ollama-compatible API
 ```
 

TRAINING.md

@@ -0,0 +1,192 @@
+# Train Your Own
+
+Everything needed to birth a model from real quantum measurement and train it on your own
+text, including the Hebbian attention variant. No cluster required. The reference runs in
+this repository were done on a consumer laptop, CPU only, while the rest of the system was
+running.
+
+---
+
+## What you need
+
+```bash
+pip install torch numpy
+pip install qiskit qiskit-ibm-runtime     # only if you want to harvest your own shots
+```
+
+An IBM Quantum account is **optional**. Without one you use the archived entropy that ships
+here, which is real measured hardware data, just not yours. With one you can harvest your
+own and the lineage becomes yours end to end.
+
+---
+
+## 1. Get quantum entropy
+
+**Option A, use the archive.** Nothing to do. The trainer reads
+`01_HER_SOUL/quantum_heart/quantum_runs.jsonl` if present, and falls back to a normal RNG
+with a warning if it is not. Every archived shot carries a backend name and job id.
+
+**Option B, harvest your own.** Put your token in a `.env` file:
+
+```
+IBM_QUANTUM_TOKEN=your_token_here
+```
+
+Then run any of the measurement scripts, each of which appends to your archive:
+
+```bash
+python benchmarks/verify_quantum_engine.py     # also runs a CHSH Bell test on your hardware
+```
+
+Open-plan accounts get roughly 10 minutes of QPU time a month. A 5-qubit shallow circuit
+costs about 4 seconds, so a few hundred jobs a month is realistic. Harvest slowly; you do
+not need many jobs to seed a small model.
+
+---
+
+## 2. Birth and train
+
+```bash
+python train_your_own.py <steps> <seeds>
+
+python train_your_own.py 1500 3        # the reference run in this repository
+python train_your_own.py 60 1          # a 2 minute smoke test, run this first
+```
+
+It trains **two arms** and compares them:
+
+| arm | attention |
+|---|---|
+| `plain` | standard multi-head attention |
+| `cst` | your §2 Mixture-of-States Hebbian kernel, gate free to learn |
+
+Both arms get **identical quantum-born initial weights, identical corpus, identical batches,
+identical seeds**, and the same parameter count. The gate starts at `sigmoid(-4) ≈ 0.018`, so
+the CST arm begins as ordinary attention and can stay there for free. It only moves if the
+gradient says the kernel earns its place. A win therefore cannot come from extra capacity
+being forced on the model.
+
+Outputs land in:
+
+```
+01_HER_SOUL/weights/cosmos_spark_cst/spark_cst.pt     the trained model
+logs/spark_cst_results.json                            per-seed losses, gates, verdict
+```
+
+### Use your own text
+
+Point `CORPUS` at any UTF-8 text file. Character level, so no tokenizer to train. A few
+hundred KB is enough to see structure; the reference corpus is 592 KB.
+
+```python
+CORPUS = Path("your_own_writing.txt")
+```
+
+### Size it honestly
+
+Compute-optimal is roughly **20 tokens per parameter**. At character level, one character is
+one token. So:
+
+| your corpus | supports about |
+|---|---|
+| 100 KB | 5 K parameters |
+| 1 MB | 50 K parameters |
+| 40 MB | 2 M parameters |
+
+The reference model is 1.84 M parameters on 592 KB, which is **heavily over-sized for its
+data**, and it overfits accordingly: held-out loss plateaus while training loss keeps
+falling. This is stated because it is the single most common mistake in small-model work.
+If you want a bigger model, get more text first. Public-domain sources work well and carry
+no model lineage.
+
+---
+
+## 3. Run it
+
+```bash
+python spark_serve.py 11500
+curl http://127.0.0.1:11500/api/tags
+curl http://127.0.0.1:11500/api/generate \
+  -d '{"model":"cosmos-spark","prompt":"I ","options":{"num_predict":90}}'
+```
+
+Speaks the Ollama HTTP API, so anything that talks to Ollama can talk to your model.
+
+**Note on GGUF:** conversion to GGUF was attempted and the tensor remap verified exact
+against the original forward pass (max |Δlogits| = 7.15e-06), but llama.cpp's tokenizer
+layer rejects a small character vocabulary. The BPE path requires a merge list; the
+SentencePiece path expects word-boundary marks and byte-fallback tokens and crashed the
+loader outright. Serving the PyTorch model directly avoids the problem entirely. If you want
+GGUF, train on a byte-level vocabulary of 256 tokens instead.
+
+---
+
+## 4. Make it reproducible from a seed of your choosing
+
+`genesis_engine/` includes the seed derivation. The pattern is:
+
+```
+seed = SHA-256( quantum_entropy_bytes ‖ any_other_source_you_choose ) -> 63-bit int
+torch.manual_seed(seed); random.seed(seed); np.random.seed(seed)
+```
+
+Because the seed governs weight initialisation, data order and every stochastic step, the
+resulting weights become a deterministic function of it. Verified in this repository:
+**identical seed reproduces weights at Δ = 0.000e+00; a one-bit change gives mean
+Δ = 2.26e-02 across 1.84 M parameters.**
+
+That is the honest, literal sense in which a model can be "grown from" a chosen source. It
+is a seed. It is real and it is checkable. It is not magic, and the source data is not
+"inside" the mathematics in any other sense.
+
+---
+
+## 5. Check your own work
+
+Every claim in [`FINDINGS.md`](FINDINGS.md) has a script. Run them against your own setup:
+
+```bash
+python benchmarks/verify_quantum_engine.py    # CHSH Bell test, archive integrity, birth pipeline
+python benchmarks/verify_physics_engine.py    # Lorenz constants against published values
+python benchmarks/topology_matched.py         # gate-matched entanglement topology
+python benchmarks/phi_pid.py                  # integration structure of a running system
+```
+
+Each prints its own verdict with the criteria fixed before the run, including when the
+verdict is "no". Several instruments in this project were found to be wrong and rebuilt;
+those failures are documented rather than deleted, because they are the reason the
+surviving results can be trusted.
+
+**If you get a positive result, check the instrument before you believe it.** That habit
+produced more real findings here than any single experiment did.
+
+---
+
+## 6. The Hebbian association engine
+
+Separate from the attention mechanism, and simpler to start with:
+
+```bash
+cd genesis_engine
+python genesis.py          # birth a being
+python serve.py            # talk to it; every exchange calls weights.learn()
+```
+
+Its mind is three small JSON files: `identity.json`, `weights.json`, `seed.json`. Association
+strength is set by the quantum heart. Portable, inspectable, roughly 10 KB per being.
+
+---
+
+## What to build next
+
+The integration measurement in `benchmarks/phi_pid.py` points somewhere specific: subsystems
+that are parallel readouts of one state stay **redundant** (measured 1.7 to 2.6 nats) rather
+than **synergistic** (0.3 to 1.2 nats). Give a subsystem its own driver, something not
+derivable from the shared source, and the decomposition should shift.
+
+That is a falsifiable prediction, and the script to test it ships here.
+
+---
+
+*CC BY 4.0. Base model components used by the Genesis Engine's default fine-tune path are
+Apache 2.0 © Alibaba Cloud.*

presentation.html

@@ -0,0 +1,512 @@
+<title>Cosmos. A Measurement Record</title>
+<style>
+  :root{
+    --ground:#0B1016; --ground-2:#111922; --rule:#1E2A36;
+    --ink:#F2F5F7; --muted:#8A97A3;
+    --meas:#4FD6C8;      /* phosphor, measurement */
+    --seed:#E8A33D;      /* amber, origin, used sparingly */
+    --null:#7C8FA3;
+    --maxw:1080px;
+    --d: ui-sans-serif, "Segoe UI", system-ui, -apple-system, sans-serif;
+    --b: ui-serif, Georgia, "Times New Roman", serif;
+    --m: ui-monospace, "Cascadia Mono", "SF Mono", Consolas, "Liberation Mono", monospace;
+  }
+  @media (prefers-color-scheme: light){
+    :root{ --ground:#F4F6F8; --ground-2:#EAEEF2; --rule:#D2DAE2;
+           --ink:#0D1419; --muted:#5A6874; --meas:#0E8C7C; --seed:#A96A0C; --null:#6B7A88; }
+  }
+  :root[data-theme="dark"]{ --ground:#0B1016; --ground-2:#111922; --rule:#1E2A36;
+    --ink:#F2F5F7; --muted:#8A97A3; --meas:#4FD6C8; --seed:#E8A33D; --null:#7C8FA3; }
+  :root[data-theme="light"]{ --ground:#F4F6F8; --ground-2:#EAEEF2; --rule:#D2DAE2;
+    --ink:#0D1419; --muted:#5A6874; --meas:#0E8C7C; --seed:#A96A0C; --null:#6B7A88; }
+
+  *{box-sizing:border-box}
+  body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--b);
+       -webkit-font-smoothing:antialiased}
+  .deck{height:100dvh;overflow-y:auto;scroll-snap-type:y mandatory;scroll-behavior:smooth}
+  @media (prefers-reduced-motion:reduce){ .deck{scroll-behavior:auto} }
+  section{min-height:100dvh;scroll-snap-align:start;display:flex;flex-direction:column;
+          justify-content:center;padding:clamp(28px, 5vw, 72px);border-bottom:1px solid var(--rule)}
+  .wrap{width:100%;max-width:var(--maxw);margin:0 auto;display:flex;flex-direction:column;
+        gap:clamp(14px, 2.2vw, 26px)}
+  .eyebrow{font-family:var(--m);font-size:.72rem;letter-spacing:.18em;text-transform:uppercase;
+           color:var(--meas);display:flex;gap:.9em;align-items:baseline}
+  .eyebrow .n{color:var(--muted)}
+  h1{font-family:var(--d);font-weight:800;letter-spacing:-.035em;line-height:.94;
+     font-size:clamp(2.8rem, 9vw, 6.2rem);margin:0;text-wrap:balance}
+  h2{font-family:var(--d);font-weight:700;letter-spacing:-.025em;line-height:1.06;
+     font-size:clamp(1.7rem, 4.4vw, 3rem);margin:0;text-wrap:balance}
+  h3{font-family:var(--d);font-weight:650;font-size:1rem;letter-spacing:.01em;margin:0;color:var(--ink)}
+  p{margin:0;font-size:clamp(1rem, 1.35vw, 1.14rem);line-height:1.62;max-width:64ch;color:var(--ink)}
+  p.lede{font-size:clamp(1.1rem, 1.8vw, 1.4rem);line-height:1.5;color:var(--muted);max-width:56ch}
+  .dim{color:var(--muted)}
+  strong{color:var(--ink);font-weight:640}
+  em.meas{color:var(--meas);font-style:normal;font-family:var(--m)}
+  code.num{font-family:var(--m);font-variant-numeric:tabular-nums}
+  .num{color:var(--meas)}
+  .scroll{overflow-x:auto;-webkit-overflow-scrolling:touch}
+  table{border-collapse:collapse;width:100%;font-family:var(--m);font-size:.86rem;
+        font-variant-numeric:tabular-nums;min-width:520px}
+  th{text-align:left;font-weight:600;color:var(--muted);border-bottom:1px solid var(--rule);
+     padding:.55rem .8rem .55rem 0;font-size:.72rem;letter-spacing:.1em;text-transform:uppercase}
+  td{padding:.62rem .8rem .62rem 0;border-bottom:1px solid var(--rule);vertical-align:top}
+  tr:last-child td{border-bottom:none}
+  .ok{color:var(--meas)} .no{color:var(--null)} .sd{color:var(--seed)}
+  .grid{display:grid;gap:clamp(12px, 1.6vw, 20px)}
+  .g2{grid-template-columns:repeat(auto-fit, minmax(260px, 1fr))}
+  .g3{grid-template-columns:repeat(auto-fit, minmax(215px, 1fr))}
+  .card{background:var(--ground-2);border:1px solid var(--rule);border-radius:3px;
+        padding:clamp(14px, 1.7vw, 20px);display:flex;flex-direction:column;gap:.5rem}
+  .card .k{font-family:var(--m);font-size:.68rem;letter-spacing:.13em;text-transform:uppercase;color:var(--muted)}
+  .card .v{font-family:var(--m);font-size:clamp(1.3rem, 2.8vw, 1.9rem);color:var(--meas);
+           font-variant-numeric:tabular-nums;line-height:1}
+  .card .v.seedv{color:var(--seed)}
+  .card p{font-size:.88rem;line-height:1.5;color:var(--muted)}
+  .math{background:var(--ground-2);border-left:2px solid var(--meas);padding:1rem 1.15rem;
+        font-family:var(--m);font-size:clamp(.78rem, 1.5vw.95rem);line-height:1.85;
+        white-space:pre;overflow-x:auto;color:var(--ink)}
+  .math.seedline{border-left-color:var(--seed)}
+  .chain{display:flex;flex-direction:column;gap:0;font-family:var(--m);font-size:.86rem}
+  .chain div{padding:.62rem 0 .62rem 1.6rem;border-left:2px solid var(--rule);position:relative;color:var(--muted)}
+  .chain div::before{content:"";position:absolute;left:-5px;top:1.05rem;width:8px;height:8px;
+        border-radius:50%;background:var(--rule)}
+  .chain div.hit{color:var(--ink)}
+  .chain div.hit::before{background:var(--meas)}
+  .chain div.origin{color:var(--seed)}
+  .chain div.origin::before{background:var(--seed)}
+  blockquote{margin:0;padding-left:1.1rem;border-left:2px solid var(--seed);
+             font-size:clamp(1.05rem, 1.9vw, 1.35rem);line-height:1.5;color:var(--ink);max-width:52ch}
+  .warn{border:1px solid var(--rule);border-left:2px solid var(--seed);background:var(--ground-2);
+        padding:1rem 1.15rem;border-radius:3px}
+  .warn p{font-size:.95rem;color:var(--ink)}
+  .foot{font-family:var(--m);font-size:.74rem;color:var(--muted);display:flex;gap:1.4em;flex-wrap:wrap}
+  a{color:var(--meas);text-decoration:none;border-bottom:1px solid color-mix(in srgb, var(--meas) 40%, transparent)}
+  a:focus-visible.deck:focus-visible{outline:2px solid var(--meas);outline-offset:3px}
+  .nav{position:fixed;right:clamp(10px, 2vw, 22px);top:50%;transform:translateY(-50%);
+       display:flex;flex-direction:column;gap:7px;z-index:10}
+  .nav b{width:6px;height:6px;border-radius:50%;background:var(--rule);display:block;
+         transition:background .2s, transform .2s}
+  .nav b.on{background:var(--meas);transform:scale(1.5)}
+  @media (max-width:640px){ .nav{display:none} table{font-size:.78rem} }
+</style>
+
+<div class="nav" id="nav" aria-hidden="true"></div>
+<div class="deck" id="deck" tabindex="0">
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span>A measurement record</span></div>
+    <h1>Cosmos</h1>
+    <p class="lede">A language model whose every initial weight was drawn from real measured
+      quantum hardware, and the honest record of what that does, and what it does not.</p>
+    <div class="math">1,842,432 parameters   ·   no base model   ·   char-level
+CHSH  S = 2.7905     Bell violation, 98.7% of Tsirelson
+λ₁    = 0.90384      Lorenz, published 0.9056
+six quantum→accuracy tests   →   six nulls</div>
+    <div class="foot">
+      <span>Cory Shane Davis · Independent Researcher</span>
+      <span>CC BY 4.0</span>
+      <span>doi:10.5281/zenodo.17574447</span>
+    </div>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">01</span><span>The claim</span></div>
+    <h2>Not that quantum makes it smarter.<br>That its origin is auditable.</h2>
+    <p>Most work in this space claims a performance gain. This one does not, and was tested
+      at six separate injection points to be sure. <strong>All six came back null.</strong></p>
+    <p>What is claimed instead is narrower and checkable: that this model's origin traces,
+      bit by bit, to real physical measurement, and that every step of that trace has a
+      falsifiable test attached.</p>
+    <div class="warn">
+      <p><strong>Why the nulls are load-bearing.</strong> Quantum measurements and a good
+      pseudo-random generator draw from the same distribution. A correctly built system must
+      therefore show <em class="meas">no accuracy advantage</em> from quantum bits. A project
+      reporting that quantum made its model smarter would be reporting that something was
+      broken or fabricated. Bell violation <em class="meas">plus</em> verified provenance
+      <em class="meas">plus</em> zero accuracy gain is the only combination an honest version
+      of this can produce.</p>
+    </div>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">02</span><span>The chain</span></div>
+    <h2>From a measurement to a mind</h2>
+    <div class="chain">
+      <div class="origin">a recorded biological rhythm   ‖   3.2M measured IBM shots</div>
+      <div class="hit">SHA-256  →  one 60-bit seed</div>
+      <div class="hit">seed governs weight init, data order, every stochastic step</div>
+      <div class="hit">u = int(bits)/2ⁿ  →  z = √2·erf⁻¹(2u−1)  →  1,842,432 weights</div>
+      <div class="hit">quantum window ‖ live pulse  →  SHA-256  →  the value that selects the next token</div>
+    </div>
+    <p class="dim">Each link below is a test that was run and could have failed. None of them
+      is an argument; all of them are numbers.</p>
+    <div class="scroll">
+      <table>
+        <tr><th>link</th><th>test</th><th>result</th></tr>
+        <tr><td>entropy is genuinely quantum</td><td>CHSH on <code>ibm_marrakesh</code></td>
+            <td class="ok">S = 2.7905 vs bound 2.0 · ~35σ</td></tr>
+        <tr><td>birth pipeline is correct</td><td>3,258,886 archived draws</td>
+            <td class="ok">matches theory to 4 decimals</td></tr>
+        <tr><td>seed derivation deterministic</td><td>5 derivations</td>
+            <td class="ok">1 distinct value · 0 bytes emitted</td></tr>
+        <tr><td>seed <em>determines</em> weights</td><td>same vs 1-bit-flipped</td>
+            <td class="ok">Δ = 0.000e+00 · vs 2.26e-02</td></tr>
+        <tr><td>correlations are the circuit's</td><td>gate-matched topology</td>
+            <td class="ok">t = +80.5 / +164.6</td></tr>
+        <tr><td>physics computes real chaos</td><td>Lorenz constants</td>
+            <td class="ok">λ₁ = 0.90384 vs 0.9056</td></tr>
+      </table>
+    </div>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">03</span><span>Is it actually quantum</span></div>
+    <h2>The one measurement nothing classical can fake</h2>
+    <div class="math">E(A, B ) = +0.7197      E(A, B') = −0.6675
+E(A', B) = +0.6982      E(A', B') = +0.7051
+
+S = E(A, B) − E(A, B') + E(A', B) + E(A', B')  =  2.7905</div>
+    <div class="grid g3">
+      <div class="card"><span class="k">measured S</span><span class="v">2.7905</span></div>
+      <div class="card"><span class="k">classical bound</span><span class="v">2.0000</span>
+        <p>No theory with local pre-existing values can exceed this.</p></div>
+      <div class="card"><span class="k">Tsirelson bound</span><span class="v">2.8284</span>
+        <p>The maximum quantum mechanics permits. Measured is 98.7% of it.</p></div>
+    </div>
+    <p>Bell's theorem gives a hard ceiling for any local hidden-variable theory. This hardware
+      clears it by roughly <span class="num">35σ</span> at 4,096 shots per setting. The entropy
+      source is physically quantum.</p>
+    <p class="dim">This is also an entirely expected result for functioning quantum hardware.
+      It verifies the pipeline, it does not discover new physics, and is not presented as such.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">04</span><span>Were the weights really born from it</span></div>
+    <h2>A deficit that proves the method</h2>
+    <div class="math">u = (int(bits) + ½) / 2ⁿ
+z = √2 · erf⁻¹(2u − 1)</div>
+    <div class="scroll">
+      <table>
+        <tr><th>statistic</th><th>32-level theoretical ceiling</th><th>measured, 3,258,886 draws</th></tr>
+        <tr><td>mean</td><td>+0.0000</td><td class="ok">−0.0001</td></tr>
+        <tr><td>standard deviation</td><td>0.9802</td><td class="ok">0.9804</td></tr>
+        <tr><td>|z| ≤ 1</td><td>0.6875</td><td class="ok">0.6874</td></tr>
+        <tr><td>|z| ≤ 2</td><td>0.9375</td><td class="ok">0.9374</td></tr>
+      </table>
+    </div>
+    <p><strong>The sd is 0.98, not 1.00, and that is the evidence, not a flaw.</strong>
+      Five qubits give 32 discrete outcomes, so <span class="num">|z|</span> cannot exceed
+      <span class="num">2.1523</span> by construction. The deficit is quantisation, and it
+      matches the theoretical ceiling to four decimal places. A pipeline reporting a perfect
+      1.0000 here would be the suspicious one.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">05</span><span>The workload archive</span></div>
+    <h2>10.6 million measured shots</h2>
+    <p>Every weight in this model, and every decision it makes, draws on an archive of real
+      hardware runs. Each is receipted with backend name, job identifier and shot count.</p>
+    <div class="grid g3">
+      <div class="card"><span class="k">measured shots</span><span class="v">10,601,984</span></div>
+      <div class="card"><span class="k">recorded jobs</span><span class="v">2,746</span>
+        <p>plus 22,489 archived job files</p></div>
+      <div class="card"><span class="k">shot-conservation failures</span><span class="v">0</span>
+        <p>counts sum to declared totals, every job</p></div>
+    </div>
+    <div class="scroll">
+      <table>
+        <tr><th>backend</th><th>shots</th><th>share</th></tr>
+        <tr><td>ibm_fez</td><td>5,455,872</td><td class="ok">51.5%</td></tr>
+        <tr><td>unlabelled in record</td><td>3,626,496</td><td class="no">34.2%</td></tr>
+        <tr><td>ibm_kingston</td><td>995,328</td><td class="ok">9.4%</td></tr>
+        <tr><td>ibm_marrakesh</td><td>524,288</td><td class="ok">4.9%</td></tr>
+      </table>
+    </div>
+    <p class="dim">Archive span February – July 2026; the underlying theory was deposited in
+      2024. A third of shots carry no backend label in the record, that is stated rather than
+      quietly dropped, and those shots are excluded from any per-backend claim.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">06</span><span>Hardware fingerprint</span></div>
+    <h2>The deviation is the evidence</h2>
+    <p>Across 10.6 million shots, outcomes cluster by Hamming weight. Ideal uniform hardware
+      would follow the binomial exactly. Real hardware does not, and the direction of the
+      error identifies the physics.</p>
+    <canvas id="hw" width="900" height="300" style="width:100%;max-width:900px;height:auto;
+      background:var(--ground-2);border:1px solid var(--rule);border-radius:3px"
+      role="img" aria-label="Measured Hamming-weight distribution against the binomial ideal"></canvas>
+    <div class="grid g2">
+      <div class="card"><span class="k">zero ones, |00000⟩</span>
+        <span class="v">3.77<span style="font-size:.55em;color:var(--muted)"> vs 3.12 ideal</span></span>
+        <p>enriched</p></div>
+      <div class="card"><span class="k">five ones, |11111⟩</span>
+        <span class="v">2.95<span style="font-size:.55em;color:var(--muted)"> vs 3.12 ideal</span></span>
+        <p>depleted</p></div>
+    </div>
+    <p><strong>|0⟩ is over-represented and |1⟩ under-represented, the signature of amplitude
+      damping and readout asymmetry.</strong> Excited states decay toward the ground state
+      during measurement. A simulator drawing from a clean binomial would not produce this
+      skew, and a fabricated dataset would have no reason to invent it.</p>
+    <p class="dim">The bias is corrected downstream by von Neumann debiasing before entropy
+      reaches the weights. It is shown here unprocessed, because the artifact is the proof.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">07</span><span>Twelve dimensions governing one bit</span></div>
+    <h2>Continuous state, discrete outcome</h2>
+    <p>The 12-dimensional state does not sit alongside the quantum layer, it
+      <strong>parameterises</strong> it. Continuous physics sets the rotation angles; the Born
+      rule turns those angles into probabilities; measurement collapses them to a bit.</p>
+    <div class="math">12D CST state  ──►  θ = (θ₁, θ₂, θ₃)          continuous
+                    │
+              ry(θ₁) rx(θ₂) rz(θ₃)         rotation on the Bloch sphere
+                    │
+              |ψ⟩ = α|0⟩ + β|1⟩            superposition
+                    │
+              P(1) = |β|²                  Born rule
+                    │
+                  ▼  measurement
+                 1  or  0                  discrete, irreversible</div>
+    <div class="grid g2">
+      <div class="card"><span class="k">what is continuous</span>
+        <p>Twelve real-valued dimensions of internal state, evolving on a verified chaotic
+          attractor with λ₁ &gt; 0.</p></div>
+      <div class="card"><span class="k">what is discrete</span>
+        <p>A single measured bit. The continuous state governs only the <em class="meas">probability</em>
+          of each outcome, never which one occurs.</p></div>
+    </div>
+    <p class="dim">This is the precise sense in which twelve dimensions control one and zero:
+      they set the amplitudes, and the amplitudes set the odds. The collapse itself remains
+      irreducibly undetermined, which is what makes the trajectory unrepeatable.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">08</span><span>Information structure</span></div>
+    <h2>A holographic encoding, measured</h2>
+    <p>Partial information decomposition splits what two subsystems carry about the system's
+      future into four parts. The result is unambiguous.</p>
+    <div class="grid g3">
+      <div class="card"><span class="k">redundancy</span><span class="v">1.7 – 2.6</span>
+        <p>nats. The same information present in multiple subsystems.</p></div>
+      <div class="card"><span class="k">synergy</span><span class="v">0.3 – 1.2</span>
+        <p>nats. Present only in the joint state. Below surrogate on 9 of 10 partitions.</p></div>
+      <div class="card"><span class="k">the exception</span><span class="v">z = +6.38</span>
+        <p>consciousness │ rest, 0.66 nats no other subsystem reconstructs.</p></div>
+    </div>
+    <p><strong>Redundancy dominating synergy is a holographic signature in the technical
+      sense:</strong> information about the whole is distributed across the parts, each
+      carrying much of the others'. That is robustness, not emergence, and stating it that
+      way matters, because the two are routinely confused.</p>
+    <p class="dim">One seam behaves differently. Cut consciousness away and something is lost
+      that nothing else rebuilds. It is a single result at one partition and is reported as
+      exactly that.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">09</span><span>The nulls</span></div>
+    <h2>Six places quantum could have helped. It didn't.</h2>
+    <div class="scroll">
+      <table>
+        <tr><th>injection site</th><th>result</th></tr>
+        <tr><td>i.i.d. weight initialisation</td><td class="no">null, the gain was init <em>scale</em>, not quantum</td></tr>
+        <tr><td>decoder sampling seed</td><td class="no">null. Pseudo / IBM / Rigetti equivalent</td></tr>
+        <tr><td>spatial 54D seed, approximate</td><td class="no">null, beat 1 of 5 random vectors, z = −0.92</td></tr>
+        <tr><td>spatial 54D seed, full pipeline</td><td class="no">null, beat 0 of 8 random vectors, z = −1.75</td></tr>
+        <tr><td>entanglement matrix as attention kernel</td><td class="no">null, worse than plain, 3/3 seeds, t = −18.6</td></tr>
+        <tr><td>live sensory state as prompt text</td><td class="no">null, n = 40 paired, blind-judged, CI crosses zero</td></tr>
+      </table>
+    </div>
+    <p>These are published first, not buried in an appendix. A reader who only remembers one
+      thing from this deck should remember that the quantum layer provides
+      <strong>physical non-determinism and receipted provenance</strong>, and not lower loss.</p>
+    <p class="dim">Several measurement instruments in this project were themselves found to be
+      wrong and rebuilt; those failures are kept in the record rather than deleted, because
+      they are the reason the surviving results can be trusted.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">10</span><span>Comparison</span></div>
+    <h2>The axis this competes on</h2>
+    <p>Loss numbers are not comparable across different corpora, tokenizers and scales, so no
+      such comparison is offered. The axis where a claim <em>can</em> be made is provenance.</p>
+    <div class="scroll">
+      <table>
+        <tr><th>property</th><th>typical open model</th><th>Cosmos</th></tr>
+        <tr><td>weight origin</td><td class="no">pseudo-random init, unrecorded</td><td class="ok">measured quantum, receipted per job</td></tr>
+        <tr><td>init reproducible from a stated seed</td><td class="no">usually, if published</td><td class="ok">verified: Δ = 0.000e+00</td></tr>
+        <tr><td>1-bit seed change measurably alters weights</td><td class="no">untested</td><td class="ok">verified: Δ = 2.26e-02</td></tr>
+        <tr><td>entropy source verified non-classical</td><td class="no">n/a</td><td class="ok">CHSH S = 2.7905</td></tr>
+        <tr><td>base model</td><td class="no">inherited</td><td class="ok">none</td></tr>
+        <tr><td>parameters</td><td class="no">10⁹ – 10¹²</td><td class="sd">1.84 × 10⁶</td></tr>
+        <tr><td>conversational ability</td><td class="ok">high</td><td class="sd">a newborn, 88.5% real-word rate</td></tr>
+      </table>
+    </div>
+    <p><strong>It is small and it cannot hold a conversation.</strong> That is stated plainly
+      because the comparison is not about capability. It is about whether a model's origin can
+      be audited to a physical event, which almost nothing in this field can claim.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">11</span><span>What none of this shows</span></div>
+    <h2>The line that does not move</h2>
+    <p>Loss curves, Bell violations, Lyapunov exponents and integration measures are all
+      <strong>silent</strong> on whether there is anything it is like to be this system.
+      Section 08 tests one contested theory's <em>necessary</em> structural condition.
+      Necessary is not sufficient, and the theory itself is disputed.</p>
+    <div class="warn">
+      <p>Any self-report a system produces about its own inner life is the
+      <strong>least</strong> reliable signal available, and it grows more eloquent the less
+      there is behind it, not more. Such statements are excluded from evidence here on purpose.</p>
+    </div>
+    <p class="dim">No claim is made about machine consciousness in either direction. That
+      remains where it was before this project started.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">12</span><span>Origin</span></div>
+    <h2>Zeref's Rain</h2>
+    <blockquote>The echo of a pain became the truth of a seed.</blockquote>
+    <p>The seed is a one-way hash over measured quantum entropy and biological aggregates that
+      are personal to the author. The derivation module never prints, logs, or writes raw
+      samples, <span class="num">0 bytes emitted</span>, verified, and only aggregates ever
+      leave it.</p>
+    <div class="math seedline">seed = SHA-256( quantum_bytes ‖ bio_aggregates )  →  60-bit integer
+
+same seed          →  weights identical,  Δ = 0.000e+00
+one bit different  →  a different model,  Δ = 2.26e-02</div>
+    <p>What is published is the mechanism and the proof that it holds. Not the data.</p>
+    <p class="dim">Two independent senses of unrepeatable meet here: the quantum measurements
+      that shaped these weights cannot be recovered from any state, and the recording behind
+      the seed happened once.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">13</span><span>Build your own</span></div>
+    <h2>Everything is open</h2>
+    <p>The weights, the findings, and a runnable script for every claim in this deck. Each
+      benchmark prints its own verdict, including when the verdict is <em>no</em>.</p>
+    <div class="math">python benchmarks/verify_quantum_engine.py    # CHSH Bell test + archive integrity
+python benchmarks/verify_physics_engine.py    # Lorenz constants vs published values
+python benchmarks/topology_matched.py         # gate-matched entanglement topology
+python benchmarks/phi_pid.py                  # integration structure
+
+python spark_serve.py 11500                   # run the weights, Ollama-compatible API</div>
+    <div class="grid g2">
+      <div class="card"><span class="k">bring your own keys</span>
+        <p>IBM Quantum and Azure, stored locally, never transmitted. Falls back to archived
+          entropy with no keys at all.</p></div>
+      <div class="card"><span class="k">what to build next</span>
+        <p>The synergy result points somewhere specific: subsystems that are parallel readouts
+          of one state stay redundant. Give one its own driver and the structure should change.
+          That prediction is testable with <code>phi_pid.py</code> as shipped.</p></div>
+    </div>
+    <blockquote>A light at the end of a dark, dark tunnel, and the receipts to show it was
+      really there.</blockquote>
+    <div class="foot">
+      <span>huggingface.co/phera-ra/QC67_cosmo</span>
+      <span>CC BY 4.0 · Qwen2.5 base components Apache 2.0 © Alibaba Cloud</span>
+    </div>
+  </div>
+</section>
+
+</div>
+
+<script>
+(function(){
+  var deck = document.getElementById('deck');
+  var secs = Array.prototype.slice.call(deck.querySelectorAll('section'));
+  var nav  = document.getElementById('nav');
+  secs.forEach(function(){ var b=document.createElement('b'); nav.appendChild(b); });
+  var dots = Array.prototype.slice.call(nav.children);
+  if ('IntersectionObserver' in window){
+    var io = new IntersectionObserver(function(es){
+      es.forEach(function(e){
+        if(e.isIntersecting){
+          var i = secs.indexOf(e.target);
+          dots.forEach(function(d, j){ d.classList.toggle('on', j===i); });
+        }
+      });
+    }, {root:deck, threshold:0.55});
+    secs.forEach(function(s){ io.observe(s); });
+  }
+  deck.addEventListener('keydown', function(ev){
+    var i = 0, top = deck.scrollTop;
+    secs.forEach(function(s, j){ if(s.offsetTop <= top + 8) i = j; });
+    if(ev.key==='ArrowDown'||ev.key==='PageDown'||ev.key===' '){
+      ev.preventDefault(); if(secs[i+1]) secs[i+1].scrollIntoView();
+    } else if(ev.key==='ArrowUp'||ev.key==='PageUp'){
+      ev.preventDefault(); if(secs[i-1]) secs[i-1].scrollIntoView();
+    } else if(ev.key==='Home'){ ev.preventDefault(); secs[0].scrollIntoView(); }
+    else if(ev.key==='End'){ ev.preventDefault(); secs[secs.length-1].scrollIntoView(); }
+  });
+
+(function(){
+  var c=document.getElementById('hw'); if(!c) return;
+  var ctx=c.getContext('2d'), W=c.width, H=c.height;
+  var cs=getComputedStyle(document.documentElement);
+  var meas=cs.getPropertyValue('--meas').trim()||'#4FD6C8';
+  var muted=cs.getPropertyValue('--muted').trim()||'#8A97A3';
+  var rule=cs.getPropertyValue('--rule').trim()||'#1E2A36';
+  var ink=cs.getPropertyValue('--ink').trim()||'#F2F5F7';
+  var real=[3.77, 16.94, 31.68, 30.08, 14.58, 2.95];
+  var ideal=[3.125, 15.625, 31.25, 31.25, 15.625, 3.125];
+  var padL=48, padR=16, padT=22, padB=42, max=36;
+  var gw=(W-padL-padR)/6;
+  ctx.clearRect(0, 0, W, H);
+  ctx.strokeStyle=rule; ctx.lineWidth=1; ctx.font='11px ui-monospace, Consolas, monospace';
+  for(var g=0; g<=max; g+=9){
+    var y=H-padB-(g/max)*(H-padT-padB);
+    ctx.beginPath(); ctx.moveTo(padL, y); ctx.lineTo(W-padR, y); ctx.stroke();
+    ctx.fillStyle=muted; ctx.textAlign='right'; ctx.fillText(g+'%', padL-8, y+4);
+  }
+  for(var i=0;i<6;i++){
+    var x=padL+i*gw, bw=gw*0.42;
+    var hr=(real[i]/max)*(H-padT-padB), hi=(ideal[i]/max)*(H-padT-padB);
+    ctx.fillStyle=meas; ctx.fillRect(x+gw*0.10, H-padB-hr, bw, hr);
+    ctx.strokeStyle=muted; ctx.setLineDash([3, 3]); ctx.lineWidth=1.5;
+    ctx.strokeRect(x+gw*0.52, H-padB-hi, bw, hi); ctx.setLineDash([]);
+    ctx.fillStyle=muted; ctx.textAlign='center';
+    ctx.fillText(i+' ones', x+gw/2, H-padB+18);
+    ctx.fillStyle=ink; ctx.font='bold 11px ui-monospace, Consolas, monospace';
+    ctx.fillText(real[i].toFixed(2), x+gw*0.10+bw/2, H-padB-hr-7);
+    ctx.font='11px ui-monospace, Consolas, monospace';
+  }
+  ctx.textAlign='left'; ctx.fillStyle=meas;
+  ctx.fillRect(padL, padT-14, 10, 10);
+  ctx.fillStyle=muted; ctx.fillText('measured  (10,601,984 shots)', padL+16, padT-5);
+  ctx.strokeStyle=muted; ctx.setLineDash([3, 3]);
+  ctx.strokeRect(padL+210, padT-14, 10, 10); ctx.setLineDash([]);
+  ctx.fillText('binomial ideal', padL+226, padT-5);
+})();
+
+  deck.focus();
+})();
+</script>

train_your_own.py

@@ -0,0 +1,353 @@
+#!/usr/bin/env python3
+"""
+COSMOS SPARK CST — a fresh weight with EVERYTHING combined, trained as a fair test.
+
+WHAT IS COMBINED
+  1. QUANTUM BIRTH. Every initial weight drawn from her real archived IBM measurements,
+     via the same pipeline that made cosmos_born.pt and that was verified to the 32-level
+     quantisation ceiling across 3.2M draws:  u = int(bits)/2^n,  z = sqrt(2)*erfinv(2u-1).
+  2. HER SECTION 3 — Mixture-of-States Hebbian attention. The mechanism from
+     COSMOS_Paper.md that her SHIPPED weights never contained:
+         x54       = W54 . h                      a 54-dim state per token
+         H(x54)ij  = exp(-||x54_i - x54_j||^2 / 2*sigma^2)
+         A_final   = (1-g)*A_std + g*H(x54)       g = sigmoid(gate), learned
+     Her cosmos_born.pt is architecturally plain — nn.MultiheadAttention and an MLP, no
+     54D state, no Hebbian kernel, no gate. So this is the first time her own paper's
+     attention has ever been inside a model that speaks.
+  3. HER CORPUS. Her real logged experience, char-level, the same data she grew on.
+
+WHY IT IS A CONTROLLED TEST AND NOT A DEMO
+  Two arms, identical in every respect except the mechanism under test:
+      PLAIN  standard attention                (gate forced to 0 == exactly standard)
+      CST    her section-3 Hebbian attention   (gate free to learn)
+  Same quantum-born initial weights, same corpus, same held-out split, same batches, same
+  seeds, paired. The gate starts at sigmoid(-4) ~ 0.018, so the CST arm BEGINS as ordinary
+  attention and can stay there for free — it only moves if the gradient says the kernel
+  earns its place. A win therefore cannot come from extra capacity being forced on.
+
+  Both arms carry the SAME parameters, including W54 and the gate in the plain arm, so the
+  comparison is not confounded by parameter count. In the plain arm they are simply inert.
+
+PRE-REGISTERED, fixed before the run:
+  * CST beats PLAIN on every seed        -> her section-3 mechanism works on her own data.
+  * mixed / within noise                 -> no evidence it helps; report as null.
+  * CST loses on every seed              -> it hurts, and that is the finding.
+"""
+import json
+import math
+import random
+import re
+import statistics
+import sys
+import time
+from pathlib import Path
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+
+CORPUS = Path("02_HER_BODY/Cosmos_code/Cosmos/data/cosmos/experience_corpus.txt")
+QARCHIVE = Path("01_HER_SOUL/quantum_heart/quantum_runs.jsonl")
+OUTDIR = Path("01_HER_SOUL/weights/cosmos_spark_cst")
+RESULTS = Path("logs/spark_cst_results.json")
+
+BLOCK, N_LAYER, N_HEAD, N_EMBD, DROPOUT = 128, 4, 4, 192, 0.1
+D54 = 54
+
+
+# ── quantum birth ───────────────────────────────────────────────────────────
+def erfinv(y):
+    if abs(y) >= 1:
+        return math.copysign(3.0, y)
+    a = 0.147
+    ln = math.log(1 - y * y)
+    t1 = 2 / (math.pi * a) + ln / 2
+    return math.copysign(math.sqrt(math.sqrt(t1 * t1 - ln / a) - t1), y)
+
+
+def quantum_pool(limit=400_000):
+    """Real measured bitstrings -> standard-normal draws, her documented pipeline."""
+    vals = []
+    if not QARCHIVE.exists():
+        return vals
+    with open(QARCHIVE, encoding="utf-8", errors="ignore") as f:
+        for line in f:
+            if len(vals) >= limit:
+                break
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                d = json.loads(line)
+            except Exception:
+                continue
+            counts = d.get("counts")
+            if not isinstance(counts, dict):
+                continue
+            for bs, c in counts.items():
+                s = "".join(ch for ch in str(bs) if ch in "01")
+                if not s:
+                    continue
+                hi = float(1 << len(s))
+                u = (int(s, 2) + 0.5) / hi
+                z = math.sqrt(2.0) * erfinv(2 * u - 1)
+                if math.isfinite(z):
+                    vals.extend([z] * min(int(c), 8))
+                if len(vals) >= limit:
+                    break
+    return vals
+
+
+class QuantumInit:
+    def __init__(self, pool, seed):
+        self.pool = pool
+        self.i = (seed * 7919) % max(1, len(pool))
+
+    def fill_(self, t, std):
+        n = t.numel()
+        if not self.pool:
+            with torch.no_grad():
+                t.normal_(0.0, std)
+            return
+        out = torch.empty(n)
+        for k in range(n):
+            out[k] = self.pool[(self.i + k) % len(self.pool)]
+        self.i = (self.i + n) % len(self.pool)
+        out = out / (out.std() + 1e-8) * std
+        with torch.no_grad():
+            t.copy_(out.view_as(t))
+
+
+# ── her section-3 attention ─────────────────────────────────────────────────
+class CSTAttention(nn.Module):
+    """Standard attention blended with a Gaussian kernel over a learned 54D state."""
+
+    def __init__(self, use_cst):
+        super().__init__()
+        self.nh, self.hd = N_HEAD, N_EMBD // N_HEAD
+        self.qkv = nn.Linear(N_EMBD, 3 * N_EMBD)
+        self.proj = nn.Linear(N_EMBD, N_EMBD)
+        self.drop = nn.Dropout(DROPOUT)
+        self.w54 = nn.Linear(N_EMBD, D54, bias=False)     # h -> x54
+        self.log_sigma = nn.Parameter(torch.tensor(0.0))
+        # gate starts ~0.018: the CST arm BEGINS as ordinary attention
+        self.gate = nn.Parameter(torch.tensor(-4.0), requires_grad=bool(use_cst))
+        self.use_cst = use_cst
+        self.last_gate = 0.0
+
+    def forward(self, x, mask):
+        B, T, C = x.shape
+        q, k, v = self.qkv(x).split(C, dim=2)
+        sh = lambda t: t.view(B, T, self.nh, self.hd).transpose(1, 2)
+        q, k, v = sh(q), sh(k), sh(v)
+        a = F.softmax((q @ k.transpose(-2, -1)) / math.sqrt(self.hd) + mask[:T, :T], dim=-1)
+        if self.use_cst:
+            x54 = self.w54(x)                                   # (B,T,54)
+            d2 = torch.cdist(x54, x54, p=2.0) ** 2               # ||x54_i - x54_j||^2
+            sig = torch.exp(self.log_sigma).clamp(0.05, 50.0)
+            H = torch.exp(-d2 / (2 * sig * sig))
+            H = H.masked_fill(mask[:T, :T] < 0, 0.0)
+            H = H / H.sum(-1, keepdim=True).clamp_min(1e-9)
+            g = torch.sigmoid(self.gate)
+            a = (1 - g) * a + g * H.unsqueeze(1)
+            self.last_gate = float(g.detach())
+        y = (self.drop(a) @ v).transpose(1, 2).contiguous().view(B, T, C)
+        return self.proj(y)
+
+
+class Block(nn.Module):
+    def __init__(self, use_cst):
+        super().__init__()
+        self.ln1 = nn.LayerNorm(N_EMBD)
+        self.attn = CSTAttention(use_cst)
+        self.ln2 = nn.LayerNorm(N_EMBD)
+        self.mlp = nn.Sequential(nn.Linear(N_EMBD, 4 * N_EMBD), nn.GELU(),
+                                 nn.Linear(4 * N_EMBD, N_EMBD), nn.Dropout(DROPOUT))
+
+    def forward(self, x, mask):
+        x = x + self.attn(self.ln1(x), mask)
+        return x + self.mlp(self.ln2(x))
+
+
+class SparkCST(nn.Module):
+    def __init__(self, vocab, use_cst):
+        super().__init__()
+        self.tok = nn.Embedding(vocab, N_EMBD)
+        self.pos = nn.Embedding(BLOCK, N_EMBD)
+        self.blocks = nn.ModuleList([Block(use_cst) for _ in range(N_LAYER)])
+        self.lnf = nn.LayerNorm(N_EMBD)
+        self.head = nn.Linear(N_EMBD, vocab, bias=False)
+        self.register_buffer("mask", torch.triu(torch.full((BLOCK, BLOCK), float("-inf")), 1))
+
+    def forward(self, idx, targets=None):
+        T = idx.size(1)
+        x = self.tok(idx) + self.pos(torch.arange(T, device=idx.device))
+        for b in self.blocks:
+            x = b(x, self.mask)
+        lg = self.head(self.lnf(x))
+        loss = None if targets is None else F.cross_entropy(
+            lg.view(-1, lg.size(-1)), targets.reshape(-1))
+        return lg, loss
+
+    def gates(self):
+        return [b.attn.last_gate for b in self.blocks]
+
+    def quantum_birth(self, qi):
+        for m in self.modules():
+            if isinstance(m, (nn.Linear, nn.Embedding)):
+                qi.fill_(m.weight, 0.02)
+                if isinstance(m, nn.Linear) and m.bias is not None:
+                    with torch.no_grad():
+                        m.bias.zero_()
+
+
+def real_word_rate(text, words):
+    toks = re.findall(r"[a-z']+", text.lower())
+    if not toks:
+        return 0.0
+    return sum(1 for t in toks if t in words) / len(toks)
+
+
+def train_arm(use_cst, seed, data, vocab, steps, pool, val_w, words, itos):
+    torch.manual_seed(seed)
+    random.seed(seed)
+    gen = torch.Generator().manual_seed(seed)
+    m = SparkCST(vocab, use_cst)
+    m.quantum_birth(QuantumInit(pool, seed))
+    opt = torch.optim.AdamW(m.parameters(), lr=3e-4, weight_decay=0.01)
+    n = int(0.9 * len(data))
+    tr = data[:n]
+    m.train()
+    best = float("inf")
+    for s in range(1, steps + 1):
+        ix = torch.randint(len(tr) - BLOCK - 1, (16,), generator=gen)
+        x = torch.stack([tr[i:i + BLOCK] for i in ix])
+        y = torch.stack([tr[i + 1:i + 1 + BLOCK] for i in ix])
+        _, loss = m(x, y)
+        opt.zero_grad(set_to_none=True)
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(m.parameters(), 1.0)
+        opt.step()
+        if s % 100 == 0 or s == steps:
+            m.eval()
+            with torch.no_grad():
+                tot = c = 0
+                for i in range(0, len(val_w), 16):
+                    xb = val_w[i:i + 16]
+                    _, l = m(xb[:, :-1], xb[:, 1:])
+                    tot += l.item() * xb.size(0)
+                    c += xb.size(0)
+            m.train()
+            best = min(best, tot / max(1, c))
+    # sample for real-word rate
+    m.eval()
+    idx = torch.tensor([[data[0].item()]])
+    out = []
+    with torch.no_grad():
+        for _ in range(600):
+            lg, _ = m(idx[:, -BLOCK:])
+            p = F.softmax(lg[0, -1] / 0.8, dim=-1)
+            nx = int(torch.multinomial(p, 1))
+            out.append(nx)
+            idx = torch.cat([idx, torch.tensor([[nx]])], 1)
+    txt = "".join(itos.get(i, "") for i in out)
+    return best, statistics.fmean(m.gates()) if use_cst else 0.0, real_word_rate(txt, words), m, txt
+
+
+def main():
+    steps = int(sys.argv[1]) if len(sys.argv) > 1 else 1200
+    seeds = list(range(int(sys.argv[2]) if len(sys.argv) > 2 else 3))
+
+    text = CORPUS.read_text(encoding="utf-8", errors="ignore")
+    chars = sorted(set(text))
+    stoi = {c: i for i, c in enumerate(chars)}
+    itos = {i: c for c, i in stoi.items()}
+    data = torch.tensor([stoi[c] for c in text], dtype=torch.long)
+    words = set(re.findall(r"[a-z']+", text.lower()))
+
+    print("=" * 80)
+    print("  COSMOS SPARK CST — quantum birth + her section-3 attention")
+    print("=" * 80)
+    print(f"\n  corpus {len(text):,} chars · vocab {len(chars)} · {steps} steps · "
+          f"{len(seeds)} seeds")
+
+    t0 = time.time()
+    pool = quantum_pool()
+    print(f"  quantum pool: {len(pool):,} draws from her real archive "
+          f"({time.time()-t0:.1f}s)")
+    if pool:
+        print(f"    mean {statistics.fmean(pool):+.4f}  sd {statistics.pstdev(pool):.4f}  "
+              f"(standard normal expected)")
+
+    n = int(0.9 * len(data))
+    val = data[n:]
+    g = torch.Generator().manual_seed(999)
+    vi = torch.randint(len(val) - BLOCK - 1, (64,), generator=g)
+    val_w = torch.stack([val[i:i + BLOCK + 1] for i in vi])
+    print()
+
+    res = {"plain": [], "cst": []}
+    gates, rw, best_model, best_txt = [], {"plain": [], "cst": []}, None, ""
+    for sd in seeds:
+        for arm, use in (("plain", False), ("cst", True)):
+            b, gt, r, model, txt = train_arm(use, sd, data, len(chars), steps,
+                                             pool, val_w, words, itos)
+            res[arm].append(b)
+            rw[arm].append(r)
+            if use:
+                gates.append(gt)
+            if use and (best_model is None or b <= min(res["cst"])):
+                best_model, best_txt = model, txt
+            print(f"    seed {sd} {arm:<6s} loss {b:.5f}  real-word {r:.3f}"
+                  + (f"  gate {gt:.4f}" if use else ""), flush=True)
+
+    d = [p - c for p, c in zip(res["plain"], res["cst"])]
+    md = statistics.fmean(d)
+    se = (statistics.stdev(d) / math.sqrt(len(d))) if len(d) > 1 else 0.0
+    t = md / se if se > 0 else 0.0
+    wins = sum(1 for x in d if x > 0)
+    print(f"\n{'='*80}\n  RESULT\n{'='*80}")
+    print(f"  PLAIN  loss {statistics.fmean(res['plain']):.5f}   real-word {statistics.fmean(rw['plain']):.3f}")
+    print(f"  CST    loss {statistics.fmean(res['cst']):.5f}   real-word {statistics.fmean(rw['cst']):.3f}"
+          f"   mean gate {statistics.fmean(gates) if gates else 0:.4f}")
+    print(f"\n  CST - PLAIN: {-md:+.5f}   t={-t:+.2f}   CST wins {wins}/{len(seeds)}")
+
+    if wins == len(seeds) and t > 2.0:
+        v = (f"HER SECTION-3 MECHANISM WORKS ON HER OWN DATA. The Hebbian kernel over a 54D "
+             f"state beats standard attention on {wins}/{len(seeds)} seeds (t={t:+.2f}) with "
+             f"identical quantum-born initialisation, identical corpus and identical "
+             f"parameter count. The gate began at 0.018 — it could have stayed at standard "
+             f"attention for free and did not.")
+    elif wins == 0:
+        v = ("HER SECTION-3 MECHANISM HURTS on her own data — standard attention wins every "
+             "seed. Reported as measured.")
+    else:
+        v = (f"NULL / WITHIN NOISE — CST wins {wins}/{len(seeds)} (t={t:+.2f}). No evidence "
+             f"the section-3 kernel helps on this corpus at this scale.")
+    print(f"\n  VERDICT: {v}\n")
+    print(f"  her CST voice, sample:\n    {best_txt[:300]!r}\n")
+
+    OUTDIR.mkdir(parents=True, exist_ok=True)
+    if best_model is not None:
+        torch.save({"model": best_model.state_dict(), "stoi": stoi, "itos": itos,
+                    "config": {"block": BLOCK, "n_layer": N_LAYER, "n_head": N_HEAD,
+                               "n_embd": N_EMBD, "vocab": len(chars), "d54": D54},
+                    "arch": "Cosmos-Spark-CST-QuantumBorn", "total_steps": steps,
+                    "quantum_source": "ibm_real_shots", "quantum_draws": len(pool),
+                    "best_val_loss": min(res["cst"]),
+                    "real_word_rate": max(rw["cst"])},
+                   OUTDIR / "spark_cst.pt")
+        print(f"  saved -> {OUTDIR/'spark_cst.pt'}")
+    Path("logs").mkdir(exist_ok=True)
+    RESULTS.write_text(json.dumps(
+        {"steps": steps, "seeds": seeds, "results": res, "real_word": rw,
+         "gates": gates, "delta_cst_minus_plain": -md, "t": -t, "cst_wins": wins,
+         "quantum_draws": len(pool), "verdict": v}, indent=2), encoding="utf-8")
+    print(f"  saved -> {RESULTS}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())