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/

Start here

Want to...	Open
See the project as a visual walkthrough	presentation.html
Understand every folder and choose a path	KIT_GUIDE.md
Set up your own local run and credentials	SETUP.md
Train the plain and CST/Hebbian-attention arms	TRAINING.md
Reproduce the measurements	FINDINGS.md and benchmarks/

The slideshow is the visual front door. The guide beside it is the clickable map: each folder explains what it contains, what it changes, and whether it is safe to edit. Bring your own IBM Quantum token or use your own local entropy archive; credentials are never included in this repository.

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)

Measured result (5 seeds, paired, control = g forced to 0, i.e. exactly standard attention):

arm	best val loss
control (standard attention)	1.2885
spatial-injection trajectory	1.2629

Δ = +0.0256 versus control, reproduced across six independent seed vectors and 39 training runs. The mechanism works.

---

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

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.

---

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

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