Project Showcase: Quantum Patterns

Quantum Patterns starts from a provocation: what if the raw material of a piece of music came from a quantum circuit, from patterns that are coherent but never repeat, and that no classical computer could fake?

Their answer is a browser-based live-coding instrument, a fork of Satori. Partitioned quantum cellular automata (PQCA) are evolved on a quantum circuit, and their measurement outcomes are captured as datasets. Those datasets load into the editor, where short scripts in plain JavaScript turn them into sound. No Python, no accounts, and no quantum background needed to start.

Peter came to quantum through his doctorate, and spent it trying to get the field out of the lab and onto the stage.

I was looking to encourage wider adoption of quantum computer music, and more broadly the use of quantum in the arts. The live coding scene was a useful blueprint: it's a culture that started in academia but is now practiced in all sorts of places, a transition I attribute to its mature ecosystem of tools and supportive community ethos.

What makes a pattern quantum

Cellular automata evolve a grid of cells by a fixed local rule, and generative artists have long prized them for the intricate, self-organizing patterns they throw off. Partitioned quantum cellular automata run that idea on a quantum circuit: cells are qubits, the update rule is a small circuit applied across overlapping partitions, and the state evolves through superposition and interference instead of a classical lookup table.

The result is material that is coherent without being predictable. The patterns carry real quantum structure, correlations produced by entanglement and shaped by phase interference, that a classical random-number generator cannot reproduce. Three gates do most of the work:

Quantum cellular automata remained a creative footnote of my thesis, and they've a real immediacy for an audience because of the visual element. I wanted to see how effective they were at generating unfolding, immersive patterns.

A cellular automaton in a dozen lines

The pattern data comes from a Qiskit and pqca script small enough to read in one sitting. It lays out a one-dimensional line of qubits, defines the two-qubit circuit applied to every cell, and steps the automaton forward, sampling one state per step. Edit the parameters, run it, and watch the excitation spread.

# PQCA quickstart: a partitioned quantum cellular automaton in a dozen lines.
import qiskit
import pqca

# Parameters
NUM_QUBITS = 10          # a 1-D line of qubits
CELL_SIZE  = 2           # qubits per cell
STEPS      = 6
INITIAL = [1] + [0] * (NUM_QUBITS - 1)   # one excitation at the left edge

# The circuit applied to every cell: a single CX on 2 qubits.
cell = qiskit.QuantumCircuit(CELL_SIZE)
cell.cx(0, 1)?Entanglement. The CX links the two qubits in a cell so their states become correlated rather than independent: the quantum core of the update rule.​

# Two offset tessellations couple the update across cell borders.
tes = pqca.tessellation.one_dimensional(NUM_QUBITS, CELL_SIZE)
frames = [
    pqca.UpdateFrame(tes, cell),
    pqca.UpdateFrame(tes.shifted_by(1), cell),?Offset tiling. Shifting the second tessellation by one qubit lets information cross cell boundaries, so cells couple instead of evolving in isolation.​
]

# Unitary mode evolves the statevector locally, sampling one state per step.
automaton = pqca.Automaton(INITIAL, frames, mode=pqca.UnitaryPQCA())?Sampled, not collapsed. Unitary mode evolves the full statevector and samples one outcome per step without collapsing it, so the automaton keeps its quantum structure as it runs. No backend or account needed.​

print(f"t=0  {INITIAL}")
for t in range(1, STEPS + 1):
    print(f"t={t}  {next(automaton)}")

Two offset tessellations are the trick: applying the update on one tiling, then a version shifted by a single qubit, lets information cross the cell borders so the automaton actually couples rather than evolving each cell in isolation. Small runs evolve locally as a statevector; larger circuits move onto real IonQ hardware, where the machine's own noise enters the pattern.

From circuit to sound

Each run of the automaton produces a stream of measurement outcomes: probabilities, amplitudes, and phase values, step by step. Those numbers are exported as JSON and become the musical material: in the browser fork of Satori, they drive pitch, rhythm, timbre, texture, and space. Satori is a terse JavaScript live-coding language, so a few lines map a dataset onto sound and you hear the result immediately, synthesized in the browser via the Web Audio API.

Paulo covers the quantum side here, but his own route into it ran through music technology.

It's been about five years that I've been integrating quantum algorithms into music practice and putting these on stage, in live performance with orchestras and in electronic live coding scenarios.

Because the pattern is quantum, the music inherits its character: structurally coherent, non-repeating, and full of the correlations that entanglement and interference produce. Peter frames the compositions less as fixed pieces than as systems of relationships and probabilities. He is after reach as much as form.

It can disseminate knowledge in a way that a paper can't.

An invitation, not instructions

Example 00 just puts the data on a grid; from 01 onward, the examples show how to map it into music with the Satori language. Open it in a browser, hit Run, and start hacking. The compositions are credited to Peter and Paulo's performance project, Teom y Puy.

We set out to fork Satori, develop some PQCA datasets, visualize them, and then develop some musical scripts. These musical outcomes are an invitation for people to play and hack them, and use them as springboards for their own ideas.

The barrier this removes is the one that has kept quantum computer music largely academic: the Python, the accounts, the hardware setup. Here it is just a browser tab and plain JavaScript. Paulo sees the same opening.

This platform is already really stage-tested, and I think it can reach a lot of people.

Make it yours

Everything is open source and MIT-licensed: the Qiskit generator that produces the PQCA datasets, and the Satori fork that turns them into music. Open the live environment in a browser, load an example, and compose with quantum-derived patterns, or generate your own datasets and extend the library.