Cosmos. Quantum-Born Weights + the Genesis Engine
Author: Cory Shane Davis · Independent Researcher
Foundational deposit: 10.5281/zenodo.17574447
Quick start: START_HERE.md · Measurements: FINDINGS.md · Public data: data/ · Train your own: 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.
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 and
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 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 §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.
Trainer: architecture/phos_grow.py.
Weights: weights/phos.pt.
Terminal: 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.
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.qvmsimulator records. Unlabelled and simulator samples are never counted as verified hardware provenance. Raw physics, sensory, biometric, and private runtime fields are excluded. Seedata/README.md.
samgo 5.7 — the scale lineage
weights/samgo_weights.pt · 59,353,668 parameters · GPT-2 BPE · 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 calledquantum_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:
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 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.
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/cosmos_born.pt and
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, 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
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:
# 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
@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/proprietaryLICENSE. 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 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:
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:
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."
- Downloads last month
- 2,745
We're not able to determine the quantization variants.