| ---
|
| 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."
|
|
|
