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.

Xinyi builds at the seam between physics and feeling, and frames the piece through the Native Hawaiian concept of lōkahi.

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.

It started with a painting

The circuit came later. The concept arrived in 2024, on a canvas, while Xinyi was living in Oʻahu, Hawaiʻi.

Painting is a meditative process in which I let my intuition for vibrations of color, light, and shape guide me through the emergence of forms rather than something pre-planned. This particular painting lived in a state of pure abstraction for a long time before I suddenly began to perceive butterfly-like forms all across the canvas.

The butterflies she found were blended into layers of ribbon-like, entangled strands, their colors shifting rather than settling into any single pure color, "almost superpositional," as she puts it. One even resembled a Lorenz butterfly she recognized immediately from classical chaos theory.

At the time she was also deep in the cultural practices of the Kānaka Maoli, including lōkahi and the healing practice of lomilomi. She was approaching the canvas the same way: restoring harmony from something initially chaotic through the act of making.

When I came across an article in Scientific American on the quantum no-butterfly effect, everything suddenly clicked and came together, and the concept for the project was born.

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 effect is known as the anti-butterfly effect, or the quantum no-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 anymore. 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

Each visual property is computed from the circuit as it runs, layer by layer. No numbers ever appear on screen.

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

The one rule I held onto throughout was that every visual parameter had to be driven by a real quantum value, nothing decorative, nothing faked. The wing opacity really is the purity, the threads really are the mutual information between the qubit pairs. When something didn't look right, the solution was not to invent a prettier number, but to find a better mapping. The beauty had to be grounded in the physics.

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.

It was important for me to get real fidelity values on the quantum hardware, the hardware is where the theory meets reality. I feel that concepts from quantum physics can become mystical in a hand-wavy way to people, particularly in artistic formats. It's true that many aspects of the theory are deeply counterintuitive, but what I love about computation is that it grounds everything neatly and concretely in reality. If entanglement or non-locality didn't exist, the algorithms wouldn't work, and the healing wouldn't actually happen!

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.

I think back to Pono Shim's words, that "we all enter this universe connected." That nothing is ever truly lost. That no matter what it may seem like, we can never fully be disconnected from anything.

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.