An environment (wind, light, a season cycle) is fixed at the start. The tree begins completely undecided — every gene is a fair coin flip. Each generation runs one circuit of thousands of shots on a real IBM Heron r2 chip. Two things come out of those shots: the per-qubit frequency (how often each gene came up 1 — this is what the tree learns from) and the single most frequent result (the branch plan you actually see drawn).
Each new generation's belief is the old one nudged toward what was just measured, plus a small random wiggle and that step's environment — then run on the chip again. Because belief keeps locking onto its own habit, entropy falls over time: the tree crystallizes, changes less, and mostly grows as it's already become. When the generations run out, the full history is replayed as this film. That loop — variation, heredity, environmental pressure — is why it's evolution, not a fresh random image every frame.
Is it really impossible to simulate? Yes, in two distinct ways.
Scale: 108 entangled qubits would need 2¹⁰⁸ numbers held in memory at
once. No classical machine can do that.
The quantum signature: the picture alone could be faked classically — so a
companion research study asks a sharper, falsifiable question: does the entangling layer leave a
spatial correlation between neighboring genes that a classical, no-entangler surrogate
can't produce? It measures the connected two-point correlation C(d) along the qubit
chain. The classical --sim surrogate is flat zero; the hardware isn't — it carries a
real correlation between bit positions (not just a shift in per-bit bias), and a
no-entangler hardware control can't reproduce it either. The signal sits ~10σ past both
baselines and is causally switched on by the entangling gates. So the connection does measurable
work no PRNG can fake — that much is proven.
Is that entanglement? Not proven yet — and the latest run is why. The original
"serial" entangler stacks its bonds hundreds of gates deep, far past the chip's coherence, so its
strong signature (an alternating c(1)≈−0.08) is tangled up with ordinary decoherence
and crosstalk. The most recent study run (2026-07-17, ibm_kingston) re-ran the same physics
with a brick-wall entangler only ~13 gates deep — shallow enough that a genuinely entangled
state should still be alive at measurement. Result: the serial c(1) fingerprint
did not carry over — it collapses toward zero, so that part was mostly depth noise — but a
distinct short-range correlation (c(2)≈+0.05–0.06) shows up only with the
entangler switched on and is absent from the layers-0 control. So the honest headline stays: the
entangling layer imprints a measurable, causal, hardware-only correlation the classical
model can't reproduce; calling it full entanglement is still an open claim, pending deeper
analysis of these brick-wall runs.
Every frame you see is one real growth step, replayed from a quantum computer. Each step is a single circuit run on IBM Heron r2 using 108 qubits (18 branch-slots × 6 bits each). One qubit-field decides one branch: its bend angle, its length, whether it forks, and whether it sprouts a leaf.
Inside each step, the circuit does four things, in order:
Ry) — puts every qubit into superposition, tilted
toward the tree's current growth habit.CX chain + controlled-Rx) —
correlates neighboring branches so nearby limbs resemble each other. A small but measurable
clustering (see the study above), not random jitter.Between steps, belief reinforces what it just measured, so the tree's character crystallizes as it matures — while hardware noise keeps every branch a little different. The bars below the tree show the live values driving the current step; hover over each to see what it means.
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 108 qubits. That's 2¹⁰⁸ amplitudes — roughly
3 × 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
108 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.