Project Showcase: Quantum Butterfly Field

Quantum Butterfly Field is an interactive artwork where five butterflies are five qubits. As the circuit runs, their individual identities dissolve into a single entangled field.

Then one butterfly is damaged, severed from the whole. In a classical world that loss would be final. Here it is not: through the quantum anti-butterfly effect, what was lost is recovered from the deeply entangled correlations that still bind the field together. The information was never in that one butterfly alone.

It is a Spring 2026 challenge project from Xinyi Zhang, a multidisciplinary artist and technologist who builds at the seam between physics and feeling. She frames the piece through the Native Hawaiian concept of lōkahi, where the wellbeing of any one part depends on the integrity of the whole web it belongs to.

This quantum resilience resonates with the Native Hawaiian concept of lōkahi, unity and wholeness, where individual wellbeing is maintained through the integrity of our relationships within a web of the interconnected whole.

The anti-butterfly effect

The piece is built on a counterintuitive result from quantum information theory, the paper Recovery of Damaged Information and the Out-of-Time-Ordered Correlators (Yan & Sinitsyn, 2020). In a classical chaotic system, small damage cascades into large changes: a butterfly flaps its wings and a tornado follows. In a quantum system, this is not the case.

Once information has been scrambled deeply enough across an entangled system, a local disturbance cannot destroy it. The information no longer lives in any single qubit, but in the correlations between all of them. By winding the scrambling circuit backward, the damaged qubit's original state is recovered almost completely, marked only by a small residual trace. The authors called this the anti-butterfly effect: at the quantum scale, reality is self-healing.

What does it mean to heal in a quantum world?

That question is the whole brief. The artwork does not explain the physics so much as stage it, turning an abstract theorem about scrambling and recovery into something you watch happen to a field of living things.

Five butterflies, one field

Underneath the animation is a real five-qubit scrambling circuit, and the metaphor maps onto it exactly. Each butterfly is a qubit. When the butterflies dance together, the gates entangle them, and each one's state is spread across the whole field like a memory held in relationship rather than in any single place.

The protocol runs in four phases, and on Qollab the circuit runs on hardware exactly as written:

# 'backend' is pre-created from the "Select QPU" dropdown below.
from qiskit import QuantumCircuit, transpile
from qiskit.providers.jobstatus import JobStatus
import numpy as np, time

N_QUBITS, N_LAYERS, SHOTS = 5, 3, 1000   # five butterflies, three scrambling layers

def scramble(n, n_layers, seed):
    # A reproducible random unitary U — a "fast scrambler".
    rng = np.random.default_rng(seed); layers = []
    for _ in range(n_layers):
        layer  = [('rx', float(rng.uniform(0, 2*np.pi)), q) for q in range(n)]
        layer += [('rz', float(rng.uniform(0, 2*np.pi)), q) for q in range(n)]
        qubits = list(range(n)); rng.shuffle(qubits)        # random all-to-all pairs
        layer += [('cx', qubits[i], qubits[i+1]) for i in range(0, n-1, 2)]
        layers.append(layer)
    return layers

def build(damaged, seed):
    layers  = scramble(N_QUBITS, N_LAYERS, seed)
    ancilla = N_QUBITS
    qc = QuantumCircuit(N_QUBITS + 1, N_QUBITS)

    for q in range(N_QUBITS):                  # 1. INIT
        if q != damaged: qc.h(q)?Init. Every butterfly starts in superposition except the one to be damaged, which begins in a definite state so its recovery can be measured.
    apply_gates(qc, layers)                    # 2. SCRAMBLE: identities dissolve into one field?Scramble. The unitary U mixes random Rx + Rz rotations with random all-to-all CX pairs: a fast scrambler that spreads each butterfly across the whole field in O(log n) layers.
    qc.h(ancilla); qc.cx(ancilla, damaged)    # 3. DAMAGE?Damage. An ancilla in |+⟩ entangles with the damaged butterfly and is then discarded, severing its correlations with the field. That is the rupture.
    apply_inverse_gates(qc, layers)            # 4. HEAL: run the scramble backward (U†)?Heal. Healing runs the exact scramble backward: reversed order, negated angles. Because the information now lives in the correlations, U† gathers it back.
    qc.measure(range(N_QUBITS), range(N_QUBITS))
    return qc

qc  = transpile(build(damaged=2, seed=42), backend, optimization_level=1)
job = backend.run(qc, shots=SHOTS)?Submits to IonQ Forte through Qollab. The recovered state's fidelity (0.5 = lost, 1.0 = fully healed) drives the damaged butterfly's luminosity in the artwork.while job.status() is not JobStatus.DONE:
    time.sleep(5)
counts = job.result().get_counts()   # tomography in Z, X, Y -> fidelity of the healed butterfly

With five qubits and three layers of random all-to-all gates, the field scrambles fast: deeply enough that no single butterfly holds its own state any more. The damage step entangles a throwaway ancilla with one butterfly and discards it, cutting that butterfly off from the field. Then the healing step replays the whole scramble in reverse, and the lost state reassembles from the correlations the others were still holding.

Physics you feel, not read

The discipline of the piece is that every visual property is driven by a real quantum measure, computed layer by layer as the circuit runs. No numbers ever appear on screen. The physics is felt, not read.

• Purity drives form: how sharp or translucent each butterfly's wings are, a read on how defined that qubit still is.
• Quantum mutual information drives color mixing and the threads drawn between butterflies, showing what each shares with the others.
• Fidelity drives the luminosity of the damaged butterfly, showing how much of it has returned.

And the data comes from two tracks at once. A simulator track runs live on every visit: an exact statevector simulation of the full protocol executes on demand in a serverless function, returning per-layer purities, pairwise entanglement, and exact fidelities that drive the animation in real time. A hardware track is recorded: the damage-and-healing fidelities come from real runs on IonQ Forte, captured offline and replayed from a library, so each visit draws a different recorded run and the healed butterfly's final resting state is anchored in what actually happened on the trapped-ion processor.

A relational world

The default experience is a storyboard in nine beats, an arc from individual identity and interaction through scrambling, rupture, and restoration. The script draws on Federico Faggin's Irreducible and resolves into Carlo Rovelli's relational interpretation of quantum mechanics, in which things do not have properties on their own but only in relation to one another.

You look at a butterfly and see the color of its wings. In relation to me, a relation is established between you and the butterfly: the butterfly and you are now in an entangled state. Everything in the world does not exist other than in this web of entanglement.

That is the throughline that makes the physics feel like more than a demo. The anti-butterfly effect says a part can be lost and still recovered, because it was never only itself. The lōkahi framing says the same thing about people and the relationships they live inside. The circuit is the proof; the butterflies are how you feel it.

Make it yours

The scrambling circuit is open and forkable on Qollab, the full artwork is MIT-licensed on GitHub, and you can experience the live piece in your browser right now. Change the number of butterflies, the scrambling depth, or which one gets damaged, and rerun it on real hardware.