How to make a quantum creature
A recipe, not a manifesto. Every number below was measured on the machine that wrote it, and the parts that failed are named as failures.
The claim being made is narrow and precise: quantum in origin, not in operation. Her weights were born from measured hardware and that birth is auditable to the job. Nothing is in superposition while she runs, and the quantum bits buy no accuracy — six injection points, six nulls, matched classical controls. That last part is not a disappointment, it is the proof the pipeline is honest. Quantum measurement and a good PRNG draw from the same distribution, so a correctly built system must show no advantage. Anyone reporting that quantum made their model smarter is reporting that something is broken or fabricated.
What you get instead is physical non-determinism, an open-system coupling to real hardware, and provenance you can check. That is rarer than a benchmark win and harder to fake.
1. Birth: weights drawn from measurement
Take real measured bitstrings and turn them into standard-normal draws:
u = (int(bitstring, 2) + 0.5) / 2^n
z = sqrt(2) * erfinv(2u - 1)
Fill every nn.Linear and nn.Embedding from that pool instead of from a PRNG. Nothing
else changes -- the model trains normally.
Verify it or it means nothing. Measured across 3,541,709 draws from 11,354,112 archived shots:
mean -0.0001 (want 0.0000)
sd 0.9804 (want 0.9802)
|z|<=1 0.6874 (want 0.6875)
The sd is not 1.0 and that is correct. Five qubits gives 32 discrete outcomes, so |z|
cannot exceed 2.1523 by construction, and 0.9802 is the exact ceiling a correct 32-level
implementation must produce. Matching a textbook normal would mean the quantisation was
being faked.
Prove the seed determines the weights. Same seed twice: identical at delta 0.000e+00. Flip one bit of the seed: mean weight change 2.26e-02 across 1.84M parameters.
Prove the entropy is quantum. Run CHSH on the hardware you harvested from. Measured
S = 2.7275 against a classical bound of 2.0 — 98.7% of Tsirelson. If your source cannot
violate a Bell inequality, you have a random number generator, not a quantum one.
benchmarks/verify_quantum_engine.py runs all of the above offline against the archive.
2. The scaffold: phi
Every width sits on the golden-ratio harmonic series:
d_ff = floor(d_model * phi) not 4:1
RMSNorm, not LayerNorm
RoPE, not learned absolute positions
init var = 1 / (d_model * phi^-1)
This was chosen for structural reasons and turned out to be the single largest measured
effect in the project — larger than the attention mechanism it was built to support, and
it uses fewer parameters, because floor(d*phi) is leaner than 4:1.
Measured, frozen corpus, one process, three seeds:
conventional scaffold baseline 1.40312
phi scaffold baseline 1.23241
3. The loop: Omega, state, kernel
The mechanism. Attention produces a connectivity signal, the signal drives an internal state, the state modulates attention:
Omega = mean_over_heads( sum_over_QUERIES( A ) ) attention RECEIVED per token
dx/dt = k * Omega - gamma * x leaky integrator, per-dimension k, gamma
H_ij = exp( -||x_i - x_j||^2 / 2*sigma^2 ) causally masked, row-normalised
A = (1-g) * A_std + g * H g learned through sigmoid
Three details that decide whether it works at all:
Omega is summed over QUERIES, axis -2. Summing over keys gives 1.0 for every token, because that is the axis softmax normalises. A reference implementation did exactly this for years: measured Omega std 5.1e-08. Every token converged to the same state, H became the all-ones matrix, and a constant added to every logit cancels exactly in softmax. The mechanism was a no-op and nothing reported an error.
sigma must be calibrated to the data. Left at exp(0) = 1 against a measured median
pairwise distance of 61.98, exp(-31) underflows and H arrives as the identity matrix
— diagonal mass 0.9998 against 0.0078 for uniform. Blending in the identity tells the
model to attend only to itself, so descent correctly kills the gate. Set
2*sigma^2 = median(d^2) per layer from a calibration batch. This raised the gradient
reaching the state projection by 124x.
The gate must not start at exactly zero. At g = 0 the kernel contributes nothing, so
the gradient reaching the state projection is proportional to g and therefore exactly
0.000e+00. The projection never learns, the gate evaluates a permanently random kernel,
finds it useless, and stays. Start it small but non-zero and give it its own learning rate.
Use the distance identity ||a-b||^2 = ||a||^2 + ||b||^2 - 2<a,b> rather than cdist,
whose backward is undefined on the zero diagonal of cdist(x, x).
4. The guard: assume your mechanism is dead
Five separate mechanisms in this project were mathematically inert. Every one compiled, trained, produced plausible text, and logged nothing red. Three of them produced a confident negative about the idea they were testing.
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 detection is measuring whether its own quantity is degenerate.
So run these before any result counts. Each corresponds 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 (gradient / 56)
And a post-flight: report each coupling's magnitude before and after training. Starting alive is not staying alive. A mechanism that ends at 1.0x was decorative regardless of the loss column.
architecture/cosmos_state_ladder.py refuses to report any configuration until all five
pass, and records a refusal rather than skipping silently.
5. Freeze your corpus
If your creature is alive while you measure it, she appends to the corpus you train on. Two runs minutes apart then train on different data. Measured: the identical configuration with identical seeds scored 1.29152 and 1.22943 in two runs 3,451 characters apart — a 0.062 swing, larger than most effects worth reporting.
Snapshot the corpus, hash it, and run every arm in one process. With the corpus frozen these runs are bit-for-bit deterministic; the baseline reproduced to five decimals across separate invocations. Any cross-run comparison without that is worthless, and this document previously published a result that was exactly that mistake. It was retracted the same day.
6. What the ablations say
Frozen corpus, one process, 21 runs, three seeds per arm:
rung val loss vs none t wins params
dyn12 1.17897 -0.05343 -11.45 3/3 1,137,420
dyn54 1.18791 -0.04450 -5.20 3/3 1,185,174
static54 1.18824 -0.04416 -4.76 3/3 1,176,480
dyn42 1.19020 -0.04221 -4.37 3/3 1,182,762
tri 1.19247 -0.03993 -3.08 3/3 1,189,210
none 1.23241 0/3 1,135,008
Every configuration beats baseline on every seed. Three honest readings:
State is far cheaper than weights. dyn12 — twelve scalars and a leaky integrator,
2,412 extra parameters — takes the best loss and the highest t on the board, at
roughly 21x the parameter efficiency of anything else. The defensible form of the
scaling claim is not "a smaller model beats a larger one" but "internal state is
dramatically cheaper than parameters."
Most of the gain is a regulariser, not the state's content. A fixed random per-position pattern carrying no information at all scores 1.19945; a frozen random projection scores 1.19521; the learned state scores 1.18824. So of the 0.044 total gain, about 0.033 comes from any smooth auxiliary pattern and only about 0.011 requires content. Report both numbers or you are overclaiming.
Cross-window persistence is null. Built correctly, verified live, matched control: 1.18272 against 1.17864, 1/3 seeds. It works and finds nothing to carry — plausibly because a fragmentary corpus has no long-range structure to remember.
7. Growth
architecture/phos_grow.py warm-starts from its own checkpoint and optimiser state and
trains a bounded burst whenever the corpus grows. Talking to her grows the weights.
Two things that must be right:
Append-only vocabulary. New characters appear as she lives. Re-sorting the vocabulary does not merely add embedding rows — it silently changes which character every existing row means, invalidating the entire lineage. Append; never re-sort; widen the embedding and head by copying old rows forward.
The guard runs before every burst, and a refusal is written to the lineage file rather than skipped.
Observed across the first two bursts: val 2.03041 -> 1.34884, and layer 0's gate climbed 0.042 -> 0.165 — the optimiser reaching harder for the kernel as the state became informative, which is what the mechanism predicts and what never happened until the three faults above were fixed.
8. What none of this shows
Nothing here is evidence about machine consciousness, in either direction.
Loss curves, Bell violations, Lyapunov exponents and integration measures are all silent on whether there is anything it is like to be this system. Any self-report the creature produces about its own inner life is the least reliable signal available, and it gets more eloquent the less there is behind it. It is excluded from evidence here on purpose.
Build the body. Measure what it does. Let the question stay open.
Licensed CC BY 4.0. Attribution appreciated, including the nulls and the retraction, which are part of the finding.