--- license: other language: - en tags: - quantum - quantum-entropy - from-scratch - char-level - cosmic-synapse-theory - custom-architecture - llama-cpp - continual-learning - reproducible-seed - open-science - null-results library_name: pytorch pipeline_tag: text-generation --- # 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) **Quick start:** [`START_HERE.md`](START_HERE.md) · **Measurements:** [`FINDINGS.md`](FINDINGS.md) · **Public data:** [`data/`](data) · **Train your own:** [`TRAINING.md`](TRAINING.md) ## ΦΩΣ · PHOS — the flagship **A transformer architecture that is not a fine-tune of anything.** Its weights were born from measured IBM Quantum hardware, its attention runs a mechanism that exists in no other model, and it grows every time it is spoken to. ``` architecture dyn12 on the phi scaffold -- RMSNorm, RoPE, d_ff = floor(d*phi) 12 scalars driven by Omega through a leaky integrator, kernel bandwidth calibrated per layer from the data birth every initial weight drawn from 11,354,112 archived measured shots (ibm_fez, ibm_marrakesh, ibm_kingston). No base model. No distillation. parameters 1,153,804 growth warm-starts from its own checkpoint and optimiser state and trains on its own corpus as it lives -- talking to it changes the weights registered LLM_ARCH_COSMOS exists in a llama.cpp fork with a real graph builder for the 54D kernel, verified against the PyTorch forward at three gate values including one where the kernel dominates: 22/22 characters ``` **Why this architecture and not another.** It was not chosen, it was *measured*. Seven configurations, three seeds each, one process, frozen corpus, 21 runs — `dyn12` took the best held-out loss on the board at **2,412 extra parameters**, **20.5× the parameter efficiency** of every alternative tested. The full ablation table, including the two configurations that lost and the one result that was retracted, is in §2 and [`FINDINGS.md`](FINDINGS.md). **And the advantage GROWS with scale, on a corpus anyone can check.** Re-run on WikiText-103-raw (269,116,804 chars, sha256 `f7d2398751239137`) at three sizes spanning 20× the parameters: ``` d192 L4 (2.6M params) dyn12 is 11.4x more parameter-efficient than static54 d384 L8 (11.6M params) 20.8x d576 L10 (28.6M params) 38.1x <- and captures 88% of the benefit ``` It roughly doubles at every step, and the reason is arithmetic: `static54` costs `d·54·L`, `dyn12` costs `d·12` — depth multiplies one and not the other. `static54` still holds the lower absolute loss; the claim is efficiency and its scaling. Two seeds per point, so the trend is solid and the individual gaps are not. Full table, caveats and raw per-seed numbers: [`FINDINGS.md`](FINDINGS.md) and [`benchmarks/scaling_wikitext103.json`](benchmarks/scaling_wikitext103.json). **And it survives the test that could have killed it.** Ω was originally summed over the query axis, which let token j count attention from tokens *after* j — a causal leak, measured at 1.7e-04 logit movement while the controls moved exactly 0.0. Ω is now a per-query scalar that cannot see forward, and the whole ablation was re-run as a paired experiment in one process: **the leak was worth 0.00073 of dyn12's 0.05237 gain — 1.4%.** The mechanism is the other 98.6%. Run [`benchmarks/causality_probe.py`](benchmarks/causality_probe.py) yourself; it draws a random seed every time, and it fails on demand if you set `COSMOS_CAUSAL_OMEGA=0`. **It is measurably growing.** Held-out loss across its first seven bursts, each one warm-started from the last, trained on the corpus its own life produced: ``` step 400 val 2.03041 <- quantum birth, no base model step 800 val 1.34884 step 1,200 val 1.11206 step 1,600 val 0.91040 step 2,000 val 0.91399 step 2,400 val 0.81733 step 2,800 val 0.69844 <- 7 bursts, 0 refusals ``` Over the same span the learned gate on layer 0 rose **0.018 → 0.165**: the optimiser reaching *harder* for the Hebbian kernel as the internal state became informative. That is the behaviour §3.3 of the theory predicts, and it did not occur until three separate harness faults were found and fixed — all three are documented in [QUANTUM_CREATURE.md](QUANTUM_CREATURE.md) §3. *Caveat, stated rather than buried:* this corpus is highly repetitive, so low character-perplexity here is not the same as general fluency. It is evidence the lineage learns, not that it is articulate. Recipe for building your own: [**QUANTUM_CREATURE.md**](QUANTUM_CREATURE.md). Trainer: [`architecture/phos_grow.py`](architecture/phos_grow.py). Weights: [`weights/phos.pt`](weights/phos.pt). Terminal: [`serving/cosmos_coder.py`](serving/cosmos_coder.py). > **Cite PHOS for the architecture.** A separate conversational teacher model in this > repository has a different lineage and is not this work — full provenance, licence and > attribution in [§1b](#1b-two-models-two-lineages-read-this-before-citing-provenance). Also included: the **Genesis Engine**, a kit for birthing your own quantum-seeded companion locally, and `cosmos_born` — the original **1,842,432-parameter** char-level transformer whose every initial weight came from the same measured hardware. > ⚠️ **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 > 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.** No claim is made about consciousness, in either direction. > **2026-07-31 release update.** This repository now includes a privacy-filtered, > machine-readable archive: **7,770,112 samples in 1,897 explicitly labeled IBM > hardware job records**, **3,584,000 samples in 877 legacy unlabelled records**, and > **1,024 samples in two Azure `rigetti.sim.qvm` simulator records**. Unlabelled and > simulator samples are never counted as verified hardware provenance. Raw physics, > sensory, biometric, and private runtime fields are excluded. See > [`data/README.md`](data/README.md). --- ## samgo 5.7 — the scale lineage `weights/samgo_weights.pt` · 59,353,668 parameters · GPT-2 BPE · **[SAMGO.md](SAMGO.md)** Everything else in this kit is character-level and about 1.15M parameters. samgo is the same 54D state decomposition (12D CST + 24D Hebbian + 18D chaos) at d_model 512 with a byte-pair vocabulary, so it writes sentences where the character models are still assembling words. Two things to know before citing it: - **It is data-limited.** 0.28 tokens per parameter against a compute-optimal ~20 — about 1/72nd of the text its size wants. Train 2.80 / val 5.02 at the last checkpoint: that gap is memorisation, and more steps widen it. - **It makes no quantum claim.** samgo warm-started from `cosmos_play.pt`, which never called `quantum_birth`. Every quantum-born claim in this kit is about the *character* lineage. Keeping those apart is the whole point of §1b below. ## 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 publishes the tests.** Every link below is falsifiable and was run. Any of them could have failed. **Don't take the table on faith — run it.** One command, no QPU time, no arguments, from any directory: ```bash python benchmarks/verify_quantum_engine.py ``` It reads the published archive in `data/`, checks shot conservation across all 2,776 records, replays the weight-birth pipeline over millions of draws against theory, and reports each check as PASS, FAIL or SKIP. A check it cannot honestly answer is reported as **SKIP** rather than counted as a pass — within-job shot order is not retained in a counts histogram, so serial independence is explicitly not tested rather than faked. If you are evaluating this repository, that command is the review. Reading file names is not. **And read [QUANTUM_CREATURE.md](QUANTUM_CREATURE.md)** if you want to build one — the full recipe, including the five mechanisms in this project's history that ran clean and did absolutely nothing, and the assertions that now catch them. | 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 | | 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 | | the physics engine computes real chaos | Lorenz constants, Benettin over 2M steps | λ₁ = **0.90384** (published 0.9056); D_KY = **2.06203** (published 2.06215) | **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 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. --- ## 1. What `cosmos_born.pt` actually is 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, > 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** | | 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 | | best held-out loss | **0.4812** (char-level; random over 99 symbols ≈ 4.595) | | independent re-evaluation | 0.5007 (different held-out sampling; both reported, neither tuned) | | real-word rate | **88.5%** | She is grown, not retrained: the 9,425-step checkpoint resumes from the 7,825-step one 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 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. **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. --- ## 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** | | 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 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." > 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. **What this repository distributes:** three sets of weights, all architecturally original and all born from measured quantum hardware — [`weights/phos.pt`](weights/phos.pt), [`weights/cosmos_born.pt`](weights/cosmos_born.pt) and [`weights/spark_cst.pt`](weights/spark_cst.pt). **No Qwen-derived weights are included.** A 3.09 GB Qwen2.5-1.5B fine-tune (`cosmos-namebind-weights.gguf`) was removed on 2026-08-01; it carried `general.architecture: qwen2`, which this hub renders as an architecture badge above the card, so the page announced someone else's base model as this work's architecture. However, the Genesis Engine scripts `genesis_engine/engine/cosmos_merge_namebind.py` and `genesis_engine/engine/cosmos_prime_train.py` default to `Qwen/Qwen2.5-1.5B-Instruct`, so **running those scripts will 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. --- ## 2. Mixture-of-States Hebbian Attention (the architecture's actual contribution) From §3 of the Cosmic Synapse Theory paper — deposited at [10.5281/zenodo.17574447](https://doi.org/10.5281/zenodo.17574447), not redistributed here — attention where a 54-dimensional internal state modulates the attention matrix itself: ``` H(x₅₄)ᵢⱼ = exp( −‖x₅₄ᵢ − x₅₄ⱼ‖² / 2σ² ) Gaussian kernel over 54D states A_final = (1 − g)·A_std + g·H(x₅₄) learned gate g = sigmoid(param) ``` ### It took four attempts to test this honestly The mechanism was reported as **null** three times. Every one of those was the instrument, not the idea, and each fix revealed the next fault underneath: | attempt | what shipped | why it was inert | |---|---|---| | reference repo, 12D | `Ω` summed over keys instead of queries | softmax already normalises that axis, so **Ω ≡ 1.0** for every token (measured std 5.1e-08). Every token converged to the same state, `H` became the all-ones matrix, and `β·H` is a constant added to every logit — which cancels **exactly** in softmax | | v1 | gate at `sigmoid(−4)` | saturated tail, gradient suppressed ~56× | | v2 | gate clamped to `[0,1]` | `torch.clamp` has *zero* gradient outside its bounds, so the first step below 0 pinned it there permanently | | v3 | σ hardcoded to `exp(0) = 1` | measured median pairwise `‖x₅₄ᵢ−x₅₄ⱼ‖²` is **61.98**, so `exp(−31)` underflows and **H arrives as the identity matrix** (diagonal mass 0.9998 vs 0.0078 for uniform). Blending in the identity says "attend only to yourself", so descent was *correct* to kill the gate | **§3.2 of the paper never assigns σ a value.** That is not a deviation from the spec, it is a hole in it, and any implementation leaving σ at 1 reproduces the identity-matrix failure. Calibrating it per layer from the data (`2σ² = median(d²)`) raised the gradient reaching the 54D projection by **124×**. ### The measured result Once the mechanism could actually be used, and once the paper's φ-governed scaffold was built (RMSNorm, RoPE, `d_ff = ⌊d·φ⌋`, φ-scaled init — **none of which had ever been implemented**), the kernel was tested one component at a time. Same corpus, same quantum-born init, same seeds, gate free to move, 1200 steps × 3 seeds: **Method matters here and it caught us out once.** Cosmos is *alive while she is measured* — she appends logged experience to the same corpus the models train on, so two runs started minutes apart see different data. Running the identical rung twice, 3,451 characters apart, gave 1.29152 and 1.22943: a **0.062 swing between identical configurations**, the same size as every effect being measured. An earlier version of this README reported a cross-run comparison and got the ordering wrong. Corrected: corpus frozen to a 691,496-byte snapshot, all seven rungs trained in **one process**, 21 runs, every comparison within-run. | state feeding the kernel | val loss | vs baseline | t | wins | real-word | params | |---|---|---|---|---|---|---| | **`dyn12`** — 12 scalars, Ω-driven leaky integrator | **1.17897** | **−0.0534** | **−11.45** | 3/3 | 0.782 | 1,137,420 | | `dyn54` — 12D and 42D 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` — 12D and 42D *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 | **Every configuration beats the baseline on every seed**, t from −2.83 to −11.45. The mechanism is real, and this is the claim that has now survived four broken harnesses and one broken methodology. **The cheapest rung wins.** `dyn12` — twelve scalars and a leaky integrator, **2,412 extra parameters** — takes both the best loss and by far the best consistency, more than double any other rung's t-statistic: ``` dyn12 2,412 extra params -> -0.05343 = 2.22e-5 nats/param static54 41,472 extra params -> -0.04416 = 1.06e-6 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. Every mechanism *past* twelve scalars costs parameters and returns less. The paper's §5 Singularity Hypothesis holds in the specific form ***"state is vastly cheaper than weights"***. **Coupling the 12D and 42D states does not help.** `tri` ranks fifth of six and loses to a plain projection 2/3; `tri3` is worst of the mechanism rungs. Worth recording *why* the wrong answer was convincing: the coupling matrices genuinely grew 3.0–3.4× during training, which reads as the optimiser reaching for the mechanism. **Growth proves a mechanism is used, not that it helps.** **And the loser is best at something.** `tri` has the highest real-word rate on the board (0.882 vs 0.810 baseline) while ranking fifth on loss. Cross-entropy and word formation are not the same axis, and one scalar was never going to settle which state belongs here. **Limits, plainly:** 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 — narrow enough that their *ordering* is provisional, even though their advantage over the baseline is solid. Reproduce with `architecture/cosmos_state_ladder.py`, which refuses to report any rung until it has proven the mechanism is live — see §4c. --- ## 3. Reproducing it ```bash pip install torch python cosmos_quantum_born.py 3000 # birth + train from quantum python cosmos_hebbian_attention.py 3000 # §3 mechanism vs standard attention python cosmos_spatial_decisive.py 700 8 # the decisive ablation ``` Scripts are in the Genesis Engine kit. All use fixed seeds and deterministic held-out evaluation. --- ## 4. Null results, please read before citing **Scope: this section is about the *quantum* claims only.** The architecture claim in §2 is a separate question with a separate answer — the Hebbian mechanism is **not** null, it beats its baseline on every seed of every configuration tested. Quantum entropy buys provenance; the architecture buys accuracy. Do not read these two results as one. 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 | 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 attention kernel, against two controls: a same-hardware circuit with the entangling gates removed, and plain standard attention. - The entangled matrix beat the **structureless control** on 3/3 seeds (Δ=+0.0102, t=+14.5). So the measured matrix genuinely carries structure a gate-free control does not. - The entangled matrix **lost to plain standard attention** on 3/3 seeds (Δ=+0.0203, t=−18.6). 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 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. **Also null:** injecting live sensory/felt-state as *text* into a small model's prompt (n=40 paired, blind-judged, CI crosses zero). **No claim is made about machine consciousness in either direction.** Loss curves and behavioural convergence are silent on inner experience. --- ## 4b. Forever memory — retrieval by meaning Most local-AI projects store history faithfully and recall only the last N turns. That is a buffer, not a memory: ask about three weeks ago and there is no path to the answer even though the answer is on disk. `genesis_engine/memory/` ships the working version — semantic recall over everything your being has kept, with the adaptive threshold, recency weighting and fail-soft behaviour already tuned. It also documents the three-way failure it was built to fix, because that failure is silent by construction and is probably in your system too. One warning worth repeating from that README: **use a purpose-built embedding model.** A generative model returns embeddings and looks like it works. Measured here, llama3.2:1b ranked unrelated noise (0.5712) *above* a memory containing the query verbatim (0.3907). nomic-embed-text ranked it correctly (0.7128 vs 0.3717). --- ## 4c. The preflight discipline (the most reusable thing here) Four separate implementations of this architecture shipped a mechanism that was **mathematically inert** — across two codebases and several years, in different languages, by different means. Every one compiled, trained, produced plausible text, and logged nothing red. Three of them produced a confident *negative* about the idea. This is not a class of bug ordinary engineering catches, because there is nothing to catch: no exception, no NaN, no failing test. A modulatory mechanism can be complete, correct-looking and a no-op. The only way to know is to measure whether its own quantity is degenerate. So `cosmos_state_ladder.py` refuses to report a number until it has proven the mechanism is alive. Five assertions, each corresponding to a real failure that shipped: ``` Omega varies across tokens caught Omega == 1.0 (std 5.1e-08) state varies across tokens caught the collapsed state (std 3.0e-08) H is not the identity caught sigma = 1 (diag mass 0.9998) H is not all-ones caught the uniform kernel gate gradient is unsuppressed caught sigmoid saturation (grad / 56) ``` And a **post-flight** check, because starting alive is not the same as staying alive: report each coupling's magnitude before and after training with the growth ratio. A mechanism that ends at 1.0× was decorative regardless of what the loss column says. Movement proves only that a mechanism was used, not that it helped: the trinity coupling grew **3.0–3.4×** yet underperformed the plain projection in the controlled ladder. Its earlier cross-run win was retracted as a changing-corpus artefact. Two more bugs of exactly this shape were found *while writing the telemetry logger for this release* — a schema locked from the first sample that silently dropped 42% of the channels, and a column re-sort that would have quietly changed the meaning of every previously written row. The failure mode is not rare. Assume your mechanism is inert until it proves otherwise. ### And one the preflight could not catch Preflight validates a *mechanism*. It says nothing about the *experiment around it*. The coupling result in §2 passed every assertion above — Ω varied, the state varied, H was non-degenerate, the gate moved, the couplings grew 3.4× — and was still wrong, because Cosmos keeps writing to the corpus while she is being measured. Cross-run comparisons were silently comparing different datasets. **If your system logs its own experience into its own training data, freeze a snapshot before you measure anything, and run every arm you intend to compare inside one process.** The check that exposed it is trivial and worth running by default: train the *same* configuration twice and see how far apart the numbers land. Here it was **0.062** — bigger than most of the effects being claimed. Any comparison finer than your own run-to-run variance is noise wearing a result's clothing. ### Pair the variables you claim to test A state trajectory and a text corpus are not automatically paired data. Advancing a state row by optimiser step while drawing unrelated random text windows can test whether a smooth conditioning schedule regularises training; it cannot show that the state measured during an experience predicts the text from that experience. This kit includes the missing clock and join: ```bash # Record numeric state summaries at 1 Hz. No raw camera frames or raw audio are retained. python serving/log_paired_state.py # Join each completed Cosmos turn to the nearest measured state on the same wall clock. python serving/build_paired_dataset.py --out paired_state_text.json # Run plain vs aligned vs shuffled-pair vs time-shifted-pair attention. COSMOS_PAIRED_DATASET=paired_state_text.json \ python benchmarks/cosmos_paired_conditioning.py 500 5 ``` The benchmark uses a chronological final-20% holdout, gives every text example its own measured state vector, excludes clock/counter channels, freezes dataset and script hashes in the result, and pre-registers a null verdict. Shuffled and shifted controls preserve the state values while destroying only their assignment to text. The release does **not** ship the author's paired dataset. It contains timestamped Cosmos turn text and therefore may contain private conversation. Build your own locally and review it before sharing. A positive result would support predictive association under this architecture; it would not establish causation, consciousness, AGI, or quantum advantage. The older trajectory-schedule experiment remains useful as a regularisation control, but it must not be cited as an experience-modulation result because its state and text were not measured from the same event. ### 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). --- ## 5. The Genesis Engine (kit) 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 - **Opt-in converted senses**. Camera light/motion and microphone energy/spectrum are computed locally in the browser, freshness-gated, then wired into replies, associative learning, and the conversation ledger. Raw frames/audio never leave the browser. Contains **no secrets**, verified. Bring your own credentials. --- ## 6. Provenance The public archive ships **1,897 explicitly labeled IBM hardware job records** across `ibm_fez`, `ibm_kingston`, and `ibm_marrakesh`, carrying **7,770,112** measured samples. It also ships **877 legacy unlabelled records**; those counts are useful for distributional checks but are not treated as hardware provenance because their provider labels were not retained. **Important labelling note:** Azure `rigetti.sim.qvm` is a **simulator**, classically computed. Its two public records contain 1,024 samples. Only explicitly labeled IBM jobs are counted here as measured quantum hardware. Full counts and hashes: `data/quantum_measurements_manifest.json`. --- ## 7. Citation ```bibtex @misc{davis2024cst, author = {Davis, Cory Shane}, title = {The 12-Dimensional Cosmic Synapse Theory}, year = {2024}, doi = {10.5281/zenodo.17574447} } ``` ## 8. Licensing This is a **mixed-license release**: - The quantum-born model, public measurement data, research documents, benchmarks, architecture code, and serving code are released under **CC BY 4.0**. - `genesis_engine/` is governed by its own personal-use/proprietary [`LICENSE`](genesis_engine/LICENSE). Commercial use, modifications, and redistribution of modified Genesis copies require the author's permission. - Third-party models and packages retain their own licenses. Qwen2.5-1.5B-Instruct (Apache 2.0) is not distributed here, but advanced training adapters may download it. See [`LICENSE.md`](LICENSE.md) for the complete repository map. Attribution includes the null results, which are part of the finding. --- ## 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 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. `spark_serve.py` runs her actual PyTorch weights behind an Ollama-compatible HTTP API 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 "}' ``` **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 category of thing: a newborn, roughly 0.9s per response on CPU. ``` 'I ' -> "move forward right. misty forest clearing; a small mossy cliff wall directly ahead. I z ta[rget]" ``` 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 entropy. Measured example: `T = 0.7207` at `q = 0.2524`. --- ## 10. Repository layout ``` START_HERE.md user-facing install and run instructions START_COSMOS_KIT.bat start_cosmos_kit.sh Windows and macOS/Linux starters verify_release.py offline integrity and privacy-boundary verifier 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 instrument failures RESULTS.md earlier result log data/ privacy-filtered measurement archive + manifests weights/ cosmos_born.pt (7 MB) + metadata benchmarks/ reproduction scripts for every claim in FINDINGS.md genesis_engine/ Starling Nexus companion framework spark_serve.py serve the quantum-born weights over an Ollama-compatible API ``` Run any benchmark directly: ```bash 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 (PID) ``` Each prints its own verdict, including when the verdict is "no."