QC67_cosmo

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

---

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 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:

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.

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.

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:

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:

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

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:

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

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