Quantum Tree

Every branch you see is drawn from a quantum genome 102 qubits on a real IBM Heron r2 chip whose genes are linked across positions, engineered clean over long range, like real DNA where nearby genes are co-inherited and distant ones interact. Those long-range links aren't wired the ordinary way they're placed by quantum teleportation: the circuit teleports the entangling gate across the chip (a Bell pair, mid-circuit measurement, classical feed-forward) so two genes 12 qubits and more apart, are correlated. For the instant those shots run, those qubits are one entangled, non-classical whole that exists only there, that moment, on that chip impossible to copy, impossible to hold in any classical memory.

An environment (wind, light, a season cycle) is fixed at the start; the tree begins completely undecided every gene a fair coin. Each generation runs one circuit of thousands of shots on the chip, then nudges its belief toward what it just measured. Because belief keeps locking onto its own habit, entropy falls over time and the tree crystallizes changing less, mostly growing as it's already become. This is the loop that makes it grow: variation + heredity + environmental pressure = evolution, one living history replayed as this film.

The picture alone could be faked classically — so a companion study asks a sharper, falsifiable question: does the entangling layer leave a real correlation between genes that no classical surrogate can produce? Getting to a clean "yes" took three iterations, each closing a hole in the last.

1. Serial entangler — the first signature. Stacked its bonds hundreds of gates deep and showed a strong alternating fingerprint (c(1)≈−0.08). Issue: depth ran far past the chip's coherence, so the signal was tangled up with ordinary decoherence and crosstalk — no way to tell real physics from noise.
2. Brick-wall entangler (2026-07-17, ibm_kingston). Re-ran the same physics only ~13 gates deep — shallow enough that a genuinely entangled state is still alive at measurement. The serial c(1) fingerprint collapsed toward zero (so that part was mostly depth noise), but a distinct short-range correlation (c(2)≈+0.05–0.06) showed up only with the entangler on, absent from the layers-0 control. Issue: these bonds were between neighbouring genes — and ordinary crosstalk also couples neighbours, so crosstalk couldn't yet be ruled out. Calling it full entanglement stayed an open claim.
3. Teleported long-range CNOT (2026-08-17, ibm_marrakesh). Closes the crosstalk gap: wires a bond between two genes 12 qubits apart, never physical neighbours — a correlation local crosstalk cannot fabricate. It teleports the gate (Bell pair across the gap, two mid-circuit measurements, classical feed-forward), costing a constant ~9 gates regardless of distance vs depth 31 for the equivalent SWAP ladder. Hardware shows a stable, single-sign correlation at 12-qubit separation (c(d)≈−0.065, reproducible across seeds, not a post-selection artifact). An exact noiseless simulation confirms the teleported gate is a genuine CNOT and that the true sign is negative — which shows on hardware, while the depth-decohered SWAP ladder washes it out and reads the wrong sign.

Where it stands: the entangling layer does measurable, causal, hardware-only work no PRNG can fake — proven at ~10σ past both baselines — and teleportation is simply the better long-range gate here: correct-signed, reproducible, and constant-depth, where SWAP routing is washed out by its own depth.

How it works

Full pipeline from code. Step by step — genome build, measure, interpret.

Genome layout — what a "genome" is

102 qubits = 17 slots × 6 bits (genome.py). One slot = one branch decision:

One shot = one full 102-bit string = one complete field of 17 branch decisions. Circuit fired many shots per generation (up to 16384).

Build — one generation circuit (build_circuit, 6 stages)

Registers: q (102 genome) + a (2 per bond, teleport ancillas) + c (genome readout) + tel (ancilla readout).

1. Belief encode — Ry(theta[i]) each qubit. Start theta = π/2 everywhere = fair coin, tree fully undecided (:453).
2. Local entangle — layers brick-wall neighbour passes: CX(i,i+1) + controlled-Rx(0.7). Correlates adjacent genes (short-range).
3. Long-range teleport CX — for each bond slot si→sj, apply CX between their angle bit-0 qubits (qi=si*6, qj=sj*6) via teleportation (_teleport_cx :201):

   H(a1); CX(a1,a2)        # Bell pair spans the gap
   CX(ctrl,a1); measure a1->tel   # inject control parity
   if tel: X(a2)                  # feed-forward
   CX(a2,tgt); H(a2); measure a2->tel
   if tel: Z(ctrl)                # feed-forward

   ctrl and tgt never physical neighbours. Constant depth regardless of gap.
4. Environment bias — Rx(angle_bias) on angle bits, Ry(season_bias) on length/fork bits, plus FORK_BIAS=0.3, LEAF_BIAS=0.45. Wind/season lean growth.
5. Self-mutation kicks — Rx(kick[i]), kick carried from previous generation (:270).
6. Collapse — measure(q→c). Each shot = one genome (:275).

Measure — shots to numbers (field_stats :288)

• p[i] = fraction of shots where bit i=1 → the per-qubit frequency, what belief learns from.
• modal = single most-frequent 102-bit string → stored as bits, the tree you actually see that gen.
• samples = next 4 frequent strings.
• diversity = mean binary entropy of p → how undecided (1=coin, 0=locked).

Heralded runs (:476): keep only shots where all tel ancilla bits = 0 (correctly-teleported branch, ~25% per bond). Filter uses ancilla bits only, never genome bits → valid noise filter, not selection bias.

Interpret — two readings

A. Research metric (correlation):

• two_point_correlation :298 — chain average C(d)=mean_i[⟨b_i b_{i+d}⟩ − ⟨b_i⟩⟨b_{i+d}⟩] c(d)=C(d)/C0 xi=Σc(d≥1)
• bond_correlations :327 — at exact bonded angle qubits: conn=⟨b_qi b_qj⟩ − ⟨b_qi⟩⟨b_qj⟩ c_at_d = conn/C0. This is the crosstalk-immune long-range signal (the headline −0.065) (best run -0.116). Classical --sim null = ~0; hardware nonzero at bond distance = entanglement signature crosstalk cannot fake.

B. Evolution (belief carried to next gen, next_belief :349):

drift = 0.18*(2p-1)      # nudge theta toward measured habit (heredity)
wig   = uniform(-0.05,0.05)   # jitter (variation)
theta_next = clamp(theta+drift+wig, 0.08, π-0.08)
kick_next  = 0.30*(2p-1)      # next-gen self-mutation

Belief locks onto its own habit → entropy falls over generations → tree crystallizes. Heredity + variation + environment = evolution, not fresh random each frame.

Interpret — tree render (buildTree JS in index.html)

Per generation, decode modal bits → 17 slots → {bend = angle/3*2−1 ∈[−1,1], length = 0.4+len/3*0.6, fork, leaf}. Walk generations as growth steps: each tip bends by slot.bend*MAXBEND + windLean, length scaled by season, fork splits tip in two, leaf sprouts, stop at MAXDEPTH. Slot picked per tip = (k+g)%17.

Loop: encode belief → run chip → measure p+modal → correlation metric + draw modal → reinforce belief → next gen. run.json stores every gen's bits/p/correlation/bonds/env; viewer replays as the film.

The full tree is 102 qubits — hard to picture. Here is the same idea shrunk to the smallest thing that still shows every mechanism: two genomes of 3 qubits each, wired the same two ways the full tree wires its genes — a local chain inside each genome, and one teleported long-range bond between them (demo_qtree.py, runnable on a real IBM chip).

• A genome = 3 qubits. Each qubit gets an Ry(angle) — its inborn lean toward 0 or 1. Measure = flip the coin. Read 3 coins = one 3-bit branch decision.
• Local bond (inside a genome). A neighbour CX chain (A0→A1→A2, and B0→B1→B2) links every gene to the whole genome — so the bits move together, like real DNA where nearby genes are co-inherited, not independent noise.
• Long-range bond = teleported CNOT. On a real chip the genomes sit far apart with no wire. A teleported CNOT applies CX(A0, B0) across the gap, exactly the block in the picture: H(a); CX(a,b) makes a Bell pair of couriers; CX(A0,a) folds A0's parity into courier a, which is measured into bell; if bell: X(b) then CX(b, B0) lets courier b act as the control on B0; finally H(b), measure, and if bell: Z(A0) close it out. Nothing is moved and nothing is destroyed — both A0 and B0 stay live and come out entangled.
• The communication. The teleported CNOT is the two genomes talking: it bonds A0 and B0 without ever making them neighbours. In the output, genome A and genome B come out correlated — that shared structure is a long-range bond crosstalk cannot fake.

Scale this from 2 genomes to 17 slots and one teleported bond to many, and you have the full tree above.

Why it's different from randomly growing a tree

A classical pseudo-random generator is just a deterministic formula: same seed, same "random" stream, every time, forever. It only looks random. Here, the randomness is physical — each qubit sits in genuine superposition, and its bit is decided by measurement collapse. Not computed. Not reproducible, even in principle.

But the deeper difference is that this superposition can't be simulated on any normal computer — not "slowly," but never, at this size. Here's why:

To track n qubits in superposition, a classical machine has to store one number (an amplitude) for every possible combination of those bits. One qubit = 2 numbers. Two qubits = 4. Ten qubits = 1,024. The cost doubles with every qubit added — exponential growth, 2ⁿ.

This tree uses 102 qubits. That's 2¹⁰² amplitudes — roughly 5 × 10³⁰ numbers to hold at once. There are only about 10⁸⁰ atoms in the entire observable universe, so storing 2¹⁰² full-precision numbers would take far more memory than could ever physically be built. No supercomputer — present or future — can hold that state. The real hardware does it for free, because the qubits are the superposition: nature isn't storing a list, it simply is all those states at once.

The usual trick for classical RNGs — sampling one bit at a time — doesn't work here, because the branches are entangled. Measuring one qubit instantly constrains its neighbors: all 102 decisions are woven into a single joint state with no shortcut. A classical computer could fake independent coin-flips, but it can't reproduce these correlations without first building the full 2¹⁰² state it can never fit in memory. That's why every run grows a different, naturally-clustered tree no ordinary machine could generate — and why --sim mode is only a rough approximation, not the real thing.