phera-ra/QC67_cosmo

Cosmos. Quantum-Born Weights + the Genesis Engine

Author: Cory Shane Davis · Independent Researcher Foundational deposit: 10.5281/zenodo.17574447 Measurements: FINDINGS.md · Train your own: TRAINING.md · Scripts: benchmarks/

A 1,842,432-parameter char-level transformer whose every initial weight was drawn from real measured IBM Quantum hardware, no base model, no distillation, no borrowed weights, plus the Genesis Engine, a kit for birthing your own quantum-seeded companion locally.

⚠️ Read this before citing. This project does not claim quantum computing makes a model more accurate. It was tested at six injection points and all six are null. That is the correct result and it is explained in §4. What is claimed, and verified with falsifiable tests, is that this model's origin is auditable to real physical 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.

---

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.

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: only cosmos_born.pt. No Qwen-derived weights are included. However, the Genesis Engine scripts genesis_engine/cosmos_merge_namebind.py and cosmos_prime_train.py default to Qwen/Qwen2.5-1.5B-Instruct, so running the kit 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 COSMOS_Paper.md §3, attention where a 54-dimensional internal state modulates the attention matrix itself:

H(x₅₄)ᵢⱼ = exp( −‖x₅₄ᵢ − x₅₄ⱼ‖² / 2σ² )        Gaussian kernel over 54D states
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

21× more parameter-efficient than the next best, and it also wins outright. 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

Every quantum harvest is receipted with backend name, job ID, and shot count. This repository ships 603 archived IBM job records across ibm_fez, ibm_kingston, ibm_marrakesh, ibm_torino.

Important labelling note: Azure rigetti.sim.qvm is a simulator, classically computed. Only IBM jobs are measured quantum hardware. Claims of "measured quantum entropy" should count IBM shots only.

---

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 repository's own work, cosmos_born.pt, the Cosmos-Spark-QuantumBorn architecture, the Genesis Engine code, the measurements and this document: CC BY 4.0.
• Qwen2.5-1.5B-Instruct, © Alibaba Cloud, Apache 2.0. Not distributed here, but the Genesis Engine's default fine-tuning base, and the lineage of the author's conversational model. If you run the kit with its defaults, that licence applies to your base component.

Attribution appreciated, including the null results, which are part of the finding.

---

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

README.md          this model card
TRAINING.md        how to birth and train your own, start to finish
train_your_own.py  quantum-born trainer, plain vs Hebbian-attention arms
FINDINGS.md        every measurement, including the nulls and the instrument failures
RESULTS.md         earlier result log
weights/           cosmos_born.pt (7 MB) + metadata
benchmarks/        reproduction scripts for every claim in FINDINGS.md
genesis_engine/    the kit, birth your own, locally
spark_serve.py     serve her own 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."