The Art Hidden in Quantum Noise: Decoherence as Aesthetic
Table of Contents
- What IS Quantum Noise?
- The Beauty of Imperfection
- How Noise Manifests in Our Measurements
- The Aesthetic Argument: Real vs. Fake Randomness
- Origin Quantum vs IBM Quantum: Two Voices
- Our Noise Texture Layer
- The Philosophical Angle
- Showcase: High-Entropy Pieces
What IS Quantum Noise?
Every quantum computer is in a war with the universe.
The moment you prepare a qubit in superposition — balanced on that knife-edge between 0 and 1 — the environment begins to intrude. Stray photons, thermal vibrations, electromagnetic whispers from a cable three meters away. The qubit starts to forget what it was supposed to be. Physicists call this decoherence.
There are two timescales that define this decay. T1 is the energy relaxation time — how long before an excited qubit falls back to its ground state, like a ball rolling downhill. T2 is the dephasing time — how long before the qubit's phase information dissolves into noise. On IBM's superconducting processors, T1 and T2 are measured in microseconds. Your circuit has a few hundred nanoseconds to run before the universe reclaims its randomness.
This is quantum noise. Not the hiss of a bad radio. Not a software bug. It is the physical universe interacting with your computation at the most fundamental level possible.
Quantum noise is not interference — it is the universe participating in your computation.
The Beauty of Imperfection
Classical computers can simulate randomness, but they cannot produce it. Every pseudorandom number generator is a deterministic function wearing a mask. Give it the same seed, and it will produce the same sequence, forever. The randomness is an illusion — a very convincing one, but an illusion nonetheless.
Quantum noise is different. It is genuinely, provably, irreducibly unpredictable. Not because we lack information about the system. Not because the computation is too complex to follow. But because the universe itself has not yet decided the outcome until the moment of measurement.
This distinction matters for art. When a generative artist uses Perlin noise or simplex noise, they are sculpting with deterministic chaos. Beautiful, yes — but ultimately repeatable. When we use quantum noise, we are sculpting with something that has never existed before and can never be reproduced. Each measurement is a one-time event in the history of the universe.
The imperfections in our quantum measurements are not flaws to be corrected. They are the signature of reality itself.
How Noise Manifests in Our Measurements
When we run our 12-qubit Hadamard + CNOT circuit on real quantum hardware, the ideal output would be a perfectly uniform distribution across all possible bitstrings. In practice, that never happens. Here is what the noise actually does:
Bit-Flip Errors
A qubit that should measure as 0 occasionally reads as 1, and vice versa. These bit-flip errors are not uniform — they depend on the physical characteristics of each individual qubit on the chip. Qubit 7 on ibm_fez might have a 0.3% error rate while qubit 42 has 1.2%. These asymmetries ripple through the measurement statistics, creating subtle biases that vary from processor to processor and even from day to day.
Decoherence Shifts
As our circuit executes, qubits lose coherence at different rates. By the time measurement happens, the probability distribution has drifted away from the ideal. Entangled pairs become partially disentangled. Superpositions partially collapse. The result is a probability landscape that is neither perfectly uniform nor completely random — it is something more interesting than either.
Processor Fingerprints
Every quantum processor has a unique noise profile. The crosstalk between neighboring qubits, the calibration drift over hours, the specific T1/T2 times of each qubit — these create a fingerprint that is as unique as a human voice. Two identical circuits run on two different processors will produce statistically distinguishable output distributions.
This is not a problem. This is a feature. Each processor leaves its mark on the art it helps create.
The Aesthetic Argument: Real vs. Fake Randomness
The generative art world runs on pseudorandomness. Perlin noise, simplex noise, Mersenne Twister, xorshift — these are the tools of the trade. They produce beautiful results. But they are deterministic. Every output is predetermined by its seed.
Our Quantum Genesis collection uses a fundamentally different source of randomness:
def build_nft_seed_circuit(num_qubits=12):
qc = QuantumCircuit(num_qubits, num_qubits)
# Hadamard layer: maximum superposition
for i in range(num_qubits):
qc.h(i)
# CNOT chain: maximum entanglement
for i in range(num_qubits - 1):
qc.cx(i, i + 1)
qc.measure_all()
return qcThis circuit creates a maximally entangled state across 12 qubits. When measured with 4,096 shots, it produces a distribution of bitstrings that encodes the quantum processor's physical state at that exact moment. We hash these measurements with SHA-512 to produce a seed, then feed it into our art generator.
The result: art that is seeded by the actual quantum state of matter. Not a simulation. Not an approximation. The real thing.
Classical generative art is a recording. Quantum generative art is a live performance that can never be replayed.
Origin Quantum vs IBM Quantum: Two Voices
Our collection was generated on two different quantum computing platforms, and the difference is audible — if you know how to listen.
NFTs #1–18: Origin Quantum WK_C180
Origin Quantum's WK_C180 is a 180-qubit superconducting processor built in Hefei, China. Its noise characteristics are distinct from IBM's hardware — different fabrication process, different qubit coupling topology, different error profiles. The first 18 pieces in our collection carry Origin's unique quantum voice.
These early pieces tend toward certain color distribution patterns and entropy profiles that reflect WK_C180's specific decoherence characteristics. They are the "origin" of our origin story — the first quantum seeds we ever harvested for art.
NFTs #19–100: IBM Quantum (ibm_fez & ibm_torino)
The remaining 82 pieces were generated on IBM's ibm_fez (156 qubits) and ibm_torino (133 qubits). IBM's Eagle and Heron processors use a heavy-hex qubit topology with different crosstalk patterns and gate fidelities. The seeds from these machines carry a detectably different statistical signature.
If you place an Origin piece next to an IBM piece, both are abstract, both are beautiful — but they come from different quantum "dialects." The noise is different. The entropy distributions are different. The art is different.
Quantum Genesis #1 — Born from Origin Quantum's WK_C180 processor. The noise texture and color distribution reflect the chip's unique decoherence profile.
Quantum Genesis #19 — The first IBM Quantum piece. Notice the shift in texture density and color harmony compared to the Origin pieces.
Our Noise Texture Layer
Each piece in Quantum Genesis has a dedicated noise texture layer — hundreds of tiny semi-transparent dots scattered across the canvas by the quantum random number generator. This layer creates a grain effect reminiscent of analog film photography or risograph printing.
The dots are not placed on a grid. They are not jittered with Gaussian noise. Each dot's position, size, and opacity is determined by a sequence of random values drawn from our QuantumRNG class:
class QuantumRNG:
"""Seeded from SHA-512 of quantum measurement hex seed.
Uses xorshift128+ style generation."""
def __init__(self, hex_seed):
digest = hashlib.sha512(hex_seed.encode()).hexdigest()
self.state = [int(digest[i:i+16], 16) for i in range(0, 64, 16)]
def next_float(self):
# xorshift128+ algorithm
s1 = self.state[0]
s0 = self.state[1]
self.state[0] = s0
s1 ^= (s1 << 23) & 0xFFFFFFFFFFFFFFFF
self.state[1] = s1 ^ s0 ^ (s1 >> 17) ^ (s0 >> 26)
return ((self.state[1] + s0) & 0xFFFFFFFFFFFFFFFF) / (1 << 64)The seed comes directly from quantum hardware. Every downstream random value inherits that quantum origin. The noise texture layer is, in a literal sense, a visualization of quantum decoherence.
Particle Layer
Beyond the noise texture, each piece also has a particle layer — larger geometric shapes (circles, arcs, lines) whose positions, sizes, and rotations are all quantum-determined. These particles create the compositional structure of each piece, while the noise texture adds depth and materiality.
Together, these layers produce art that feels organic and physical despite being entirely digital. The quantum noise gives each piece a tactile quality that deterministic generators struggle to achieve.
Quantum Genesis #42 — A high-entropy piece from ibm_fez. The dense noise texture creates an almost photographic grain across the triadic color palette.
The Philosophical Angle
Here is the thing about quantum measurement that most people miss: it is not observation in the ordinary sense. When you measure a qubit, you are not discovering a pre-existing value. You are forcing the universe to make a choice that did not exist until that moment.
This is not metaphor. This is the experimentally verified, mathematically precise description of what happens during quantum measurement. Bell's theorem, tested and confirmed in countless experiments, proves that the measurement outcomes cannot have been predetermined. The universe genuinely decides at the moment of measurement.
Each of our 100 NFTs is a frozen record of 4,096 such decisions. Forty-nine thousand one hundred fifty-two individual qubits (12 qubits times 4,096 shots) were forced to choose, and their collective choice became the seed for a unique piece of art.
Each NFT is not a picture of randomness. It is a fossil of quantum decisions — moments when the universe chose, and we captured what it chose.
Why Quantum Phase Matters
Each piece in the collection is assigned a Quantum Phase attribute based on its entropy characteristics:
- Superposition — The state of pure potential, before the universe decides. High entropy, balanced distributions.
- Interfering — Quantum waves overlapping, creating patterns of reinforcement and cancellation. Medium-high entropy with visible structure.
- Entangled — Qubits bound together, their fates correlated across space. Distinctive correlation patterns in the measurement data.
- Collapsed — The moment of decision. Lower entropy, stronger biases — the noise has spoken most forcefully in these pieces.
These are not arbitrary labels. They reflect genuine statistical properties of the quantum measurement data that seeded each piece. A "Collapsed" piece looks and feels different from a "Superposition" piece because the underlying quantum data is structurally different.
Showcase: High-Entropy Masterpieces
The highest-entropy pieces in the collection are, in a mathematical sense, the most "quantum" — their seeds came from measurements closest to the theoretical ideal of perfect randomness. Here are some of the most striking:
Quantum Genesis #7 — An Origin Quantum piece with near-maximum entropy. The complementary color harmony and fine grain texture create an almost cosmic quality, as if peering into the quantum vacuum itself.
Quantum Genesis #73 — An IBM Quantum piece in the "Entangled" phase. The split-complementary palette and layered particles create a sense of depth that pulls you inward, as if falling into a quantum potential well.
Decoherence Is the Medium
We did not set out to make art about quantum physics. We set out to make art with quantum physics. The distinction matters. The quantum noise is not a theme or a metaphor in our work. It is the material itself — the paint, the canvas, and the brush all at once.
Every imperfection in our quantum measurements made the art more interesting, more varied, more alive. The decoherence that quantum engineers spend billions trying to eliminate is exactly what makes each of our 100 pieces unique.
Perhaps there is a lesson in that. The noise is not the enemy. The noise is the art.
The collection described in this post is on-chain: Quantum Genesis (100 pieces, Polygon).
Desenvolvo sistemas que usam hardware quântico real (IBM Quantum, Origin Quantum) para gerar arte e NFTs com proveniência verificável on-chain. Escrevo sobre computação quântica aplicada, criptografia, Web3 e arte generativa — tudo com código que roda em processadores quânticos de verdade.
Comentários
Postar um comentário