Why quantum randomness is the interesting part of generative art

There's a gap between how generative art feels and how it actually works, and it took us a while to get honest about it. Every generative project leans on "randomness" for its uniqueness — but under the hood, most of them are running a deterministic PRNG. Same internal state, same output, always. The stronger claim we wanted to make for Quantum Genesis wasn't about aesthetics; it was about the seed itself coming from a quantum measurement, which is a different kind of event than a PRNG step.

This post is about that difference in concrete terms, because "quantum randomness" gets thrown around a lot and rarely pinned down. It covers why classical generative art is pseudorandom, what a real measurement changes, and the math behind why two seeds essentially can't collide. No real investment thesis here — we're an experiment and a study case, not an opportunity.

The catch under every Math.random()

Every generative art project you've seen — Art Blocks, fxhash, Tyler Hobbs' Fidenza — shares a fundamental limitation: pseudorandomness.

When an artist writes Math.random() or uses a seeded PRNG, they're using a deterministic algorithm. Given the same internal state, you get the same output, always. The "randomness" is an illusion — a sufficiently motivated actor with enough compute could reverse-engineer the seed, reproduce the piece, or predict future outputs.

For somebody choosing a piece as a lasting record, this matters, because provenance requires irreproducibility. If the generative process can be replicated, the uniqueness rests on social agreement rather than anything in the math.

What a real measurement changes

Quantum Genesis operates on a different physics entirely. When you put a qubit in superposition via a Hadamard gate and measure it, the outcome (0 or 1) is governed by the Born rule of quantum mechanics. No hidden variable determines it, no algorithm produces it — it simply happens, a fundamentally unpredictable event at the physical level.

Our pipeline:

  1. 12-qubit circuit on real hardware (IBM Quantum ibm_fez / Origin Quantum WK_C180).
  2. 4,096–8,000 shots per NFT — each shot a quantum measurement.
  3. Measurement distribution → SHA-256 → 256-bit quantum seed.
  4. Deterministic RNG drives every visual decision from that seed.

The art is deterministic from the seed. But the seed came from quantum physics, and it physically cannot be reproduced — not by us, not by anyone, not with infinite compute. The measurement event existed for a microsecond and then collapsed. The information is gone from the universe except for what we recorded.

Quantum Genesis #47

Why two seeds can't coincide

Each NFT's seed is a 256-bit hex string (64 characters). The seed space: 2²⁵⁶ ≈ 1.15 × 10⁷⁷ possibilities. For perspective: there are roughly 10⁸⁰ atoms in the observable universe — the seed space is a meaningful fraction of that scale.

But the argument is stronger than the size of the space. Classical generative art takes seeds from a PRNG with a much smaller, predictable state space. Our seeds come from the full probability distribution of a 12-qubit system measured thousands of times. The min-entropy of our seeds is provably higher than any classical source, and the collision probability is effectively zero — not "astronomically low," but physically impossible within the lifetime of the universe.

Provenance that can be run, not believed

Every Quantum Genesis NFT carries immutable on-chain and on-IPFS metadata:

  • Quantum seed — the SHA-256 hex, verifiable by anyone running our open-source generator.
  • Processor identity — IBM ibm_fez, ibm_torino, or Origin WK_C180.
  • Timestamp — exact measurement microsecond (ISO 8601).
  • Shots count — 4,096 (IBM) or 8,000 (Origin).
  • Circuit specification — 12 qubits, H + CNOT topology.
  • Entropy metrics — level, score (0–100), configuration type.

Verification is trivial: take the seed from the metadata, run the generator, get the exact same SVG. The seed's origin is a quantum measurement at a specific time on a specific processor. Whether that history is worth recording is a question about provenance, not about price — and it's the question I'm genuinely curious to hear others reason through.

Comments

Post a Comment

Popular posts from this blog

Getting Your Collection Visible on OpenSea, Step by Step

Image
Once the contract is deployed and the tokens are minted with metadata on IPFS, the next step is making them discoverable somewhere people actually browse. For us that meant OpenSea, and the process turned out to be less obvious than the one-and-done marketing made it sound. This guide is the step-by-step I ended up following, using our own collection ( Quantum Genesis on Polygon) as the running example. The good news if you're on Polygon, like us: listing a token for sale is gas-free for the seller because it's a signed off-chain order, not a transaction. Before you start Make sure these are in place first: A deployed ERC-721 or ERC-1155 contract — OpenSea auto-detects contracts on Ethereum, Polygon, Arbitrum, Optimism, Base, Avalanche, and other supported chains. Minted NFTs — tokens must exist on-chain; OpenSea reads directly from the blockchain. Metadata on IPFS or a reliable host — each token's tokenURI must resolve to valid JSON with name , description , imag...
Read more

Polygon versus Ethereum for an NFT contract, from the gas bills up

Image
When we set out to put the Quantum Genesis collection on-chain, the first question wasn't about art or metadata. It was: where do we deploy? The answer looks obvious in hindsight, but only because we sat down and counted the actual costs before writing a single transaction. We minted 100 pieces on Polygon for roughly $1 in gas. The same operations on Ethereum mainnet would have run us $500 to $2,000 depending on the day. That gap shaped every decision that followed, so I want to walk through the numbers we saw and the tradeoffs we accepted along the way. Fair warning up front: Polygon is not a strict upgrade over Ethereum. It's a different security model with real compromises. Our reasoning was that for recording ownership of generative art, those compromises were acceptable. Here's the comparison that convinced us, and the cases where I'd make the other choice. The numbers that mattered Ethereum gas is a moving target, so any figure you read is a snapshot. A stand...
Read more

Quantum Error Correction, or Why Your Qubits Forget What They Were Doing

Image
Every time I ran a circuit on IBM's ibm_fez to generate art for the Quantum Genesis collection, the results were never perfectly clean. There was always noise. Errors crept into every measurement, every gate operation, every qubit interaction. Most people read that as a problem. I turned it into the whole point of the project. But before I could appreciate the noise, I had to understand what it actually is. Quantum computers leak information. They forget. They are not like your laptop, where a bit stays a bit until you tell it otherwise. A qubit is a fragile thing, and the whole industry is spending enormous effort just trying to keep one honest. This post is about how that works — the error correction codes, why the naive "copy it three times" trick fails, and where the field actually stands today. Why qubits fail A classical bit stored as a voltage in a transistor stays 0 or 1 reliably as long as the circuit has power. Copy it a billion times and it won't deg...
Read more