The infrastructure behind Quantum Genesis: qubits to Polygon

This is the post I wanted to read before we started. After the 100 pieces were minted, I went back through our notes, the deployment logs, and the code, and wrote down exactly how each layer was built — including the rough edges (the queue time on ibm_fez, pyqpanda3 shipping breaking changes mid-project). Not because any of it is glamorous, but because the whole point of this project is that the pipeline can be checked. If you're going to trust that the seeds came from real hardware, the infrastructure itself has to be open.

At a glance, Quantum Genesis is a distributed quantum-classical pipeline spanning three compute paradigms. Every layer is auditable, every transition is deterministic. The only non-deterministic event — the quantum measurement — happens once, is recorded, and from that moment the entire pipeline becomes reproducible from a single seed.

System architecture

┌─────────────────┐     ┌──────────────────┐     ┌────────────────────┐
│  QUANTUM LAYER  │────▶│  CLASSICAL LAYER │────▶│   BLOCKCHAIN LAYER │
│                 │     │                  │     │                    │
│ IBM Quantum     │     │ SHA-256 Seed     │     │ Polygon Mainnet    │
│ Origin Quantum  │     │ Deterministic    │     │ ERC-721 + EIP-2981 │
│ 4,096–8,000     │     │ RNG (xorshift)   │     │ 5% Royalties       │
│ shots/NFT       │     │ SVG Generation   │     │ Metadata Frozen    │
└─────────────────┘     │ PNG + IPFS       │     └────────────────────┘
                        └──────────────────┘

Quantum Genesis #19 — the first IBM Quantum ibm_fez piece

The quantum layer

IBM Quantum: SamplerV2 on ibm_fez / ibm_torino

We used Qiskit Runtime's SamplerV2 primitive — the production-grade interface for near-term quantum algorithms. Key decisions:

  • Transpilation: generate_preset_pass_manager(optimization_level=1) — balances circuit depth against fidelity for 12-qubit GHZ-style circuits on 156/133-qubit heavy-hex topologies.
  • Error mitigation: twirled readout error mitigation (TREM), enabled by default in SamplerV2.
  • Shots: 4,096 per NFT — statistically significant for entropy extraction while keeping queue time reasonable (~19s/NFT on ibm_fez).
  • Batch submission: 20 circuits per job to amortize queue overhead.

Circuit specification: 12 qubits, H on all (superposition), CNOT ladder (entanglement), measure all. That creates a maximally entangled state whose measurement outcomes are fundamentally unpredictable.

Origin Quantum: pyqpanda3 on WK_C180

Access via the QCloudService API. Different SDK, different topology:

  • Measurement syntax: measure([0,1,2...], [0,1,2...]) — explicit qubit→classical bit mapping.
  • Shots: 8,000 per NFT — higher for entropy margin on less-characterized hardware.
  • Latency: ~45s/NFT including API overhead.

The first 18 NFTs (1–18) came from Origin; the remaining 82 (19–100) from IBM. Both produce cryptographically equivalent seeds.

Quantum Genesis #42 — IBM Quantum ibm_fez

From measurement distribution to seed

Raw quantum output: a probability distribution over 2¹² = 4,096 possible bitstrings, each with a count from N shots.

We don't hash a single shot — we hash the entire distribution:

def derive_quantum_seed(measurement_counts: dict, shots: int) -> str:
    """
    measurement_counts: {bitstring: count} from quantum hardware
    Returns: 64-char hex string (256-bit seed)
    """
    # Serialize deterministically: sorted by bitstring
    serialized = ''.join(f'{bs}:{count}' for bs, count in sorted(measurement_counts.items()))
    # Domain separation: include shots and processor ID
    domain = f'QGENESIS:v1:shots={shots}:{serialized}'
    return hashlib.sha256(domain.encode()).hexdigest()

Why the full distribution? A single shot carries roughly one bit of entropy. The distribution of 4,096 shots over 4,096 outcomes captures the full quantum state statistics — min-entropy scales with shots. Our seeds have provably higher entropy than any single-shot derivation.

Deterministic RNG from the seed

The 256-bit seed initializes a custom QuantumRNG based on xorshift128+ seeded by SHA-512:

class QuantumRNG:
    def __init__(self, seed_hex: str):
        # SHA-512 expands 256-bit seed to 512-bit state
        state = hashlib.sha512(bytes.fromhex(seed_hex)).digest()
        self.s = [int.from_bytes(state[i:i+8], 'little') for i in (0, 8, 16, 24)]

    def next_u64(self) -> int:
        s0, s1, s2, s3 = self.s
        result = (s0 + s3) & 0xFFFFFFFFFFFFFFFF
        t = s1 << 17
        self.s[2] = s2 ^ s0 ^ t ^ (t >> 45)
        self.s[3] = s3 ^ s1 ^ (s1 >> 27)
        self.s[0] = s0 ^ s2 ^ (s0 >> 25)
        self.s[1] = s1
        return result

    def random(self) -> float:
        return self.next_u64() / 2**64

Properties:

  • Period: 2¹²⁸ − 1 (plenty for 100 NFTs × ~10⁴ calls each).
  • Equidistribution: 64-bit output passes the BigCrush test suite.
  • Deterministic: same seed → identical visual output, every time.
  • No external dependencies: pure Python, auditable.

Turning the RNG into an image

The RNG drives every visual parameter through a curated design system:

PrimitiveParameters Driven by RNG
CirclesCount (3–12), radii, positions, stroke/fill, gradients
RectanglesCount, dimensions, rotation, corner radius, skew
EllipsesRadii, rotation, stroke width, dash patterns
Bézier curvesControl points, stroke, fill, symmetry
PolygonsSides (3–12), radius, rotation, star vs convex
GradientsType (linear/radial), stops, colors, angle

Color harmony is algorithmic, not random:

  • Complementary — base hue + 180°
  • Analogous — base hue ± 30°
  • Triadic — base hue, +120°, +240°
  • Split-complementary — base hue, ±150°
  • Tetradic — two complementary pairs

Perceptual uniformity comes from OKLCH color space, not HSL/RGB. That is what keeps pieces visually harmonious regardless of what the RNG happens to emit.

Pinning everything to IPFS

Each NFT gets two IPFS pins:

  1. Image (PNG) — 2048×2048, lossless, ~200–500KB.
  2. Metadata (JSON) — ERC-721 standard plus Quantum Genesis extensions.

Three-fold pinning redundancy:

  • Pinata (primary, managed).
  • Local IPFS node (self-hosted, always online).
  • Filebase (S3-compatible, geographic redundancy).

Metadata schema (abridged):

{
  "name": "Quantum Genesis #42",
  "description": "Seeded by IBM Quantum ibm_fez measurement...",
  "image": "ipfs://bafybei.../42.png",
  "external_url": "https://quantumartlab.com/genesis/42",
  "attributes": [
    {"trait_type": "Quantum Seed", "value": "2cf1b403..."},
    {"trait_type": "Processor", "value": "IBM ibm_fez"},
    {"trait_type": "Entropy Level", "value": "Maximum"},
    {"trait_type": "Entropy Score", "value": 97},
    {"trait_type": "Qubit Config", "value": "GHZ-12"},
    {"trait_type": "Quantum Phase", "value": "Entangled"},
    {"trait_type": "Color Harmony", "value": "Triadic"},
    {"trait_type": "Complexity Score", "value": 84},
    {"trait_type": "Shots", "value": 4096},
    {"trait_type": "Timestamp", "value": "2026-03-19T14:23:12.000Z"}
  ]
}

Quantum Genesis #55 — minted via web3.py on Polygon

The contract on Polygon

Custom Solidity contract deployed on Polygon mainnet (0x488fCfaEA5fDf1cF6BAED5e8A34D7858033E1a27):

  • Batch minting: mintBatch(address[] to, uint256[] tokenIds) — 10–20 NFTs per tx.
  • Gas per NFT: ~35,000 (vs ~150,000 on Ethereum mainnet).
  • EIP-2981 royalties: 5% to creator, enforced by all compliant marketplaces.
  • Metadata freezing: setTokenURI called once after the full batch upload, then _frozen = true.
  • No admin keys: the owner can only withdraw royalties, never modify the contract.

Total deployment plus 100 mints: ~$8.40 MATIC. The same batch on Ethereum mainnet: $200–400.

Verifying a seed, end to end

Every claim is reproducible by anyone with the seed:

  1. Clone: git clone https://github.com/marceloclaudecode01/quantum-art-lab
  2. Install: pip install -r requirements.txt
  3. Run: python generate.py --seed 2cf1b4034f223f5c3e6a83019656e65597828ae375db07b2ef358ac523dde706
  4. Output: identical SVG → identical PNG → identical IPFS hash.

The generator is deterministic, dependency-minimal, and versioned. If the seed produces the art, the provenance is proven — no trust required, only math and physics. The full pipeline lives on GitHub, and if you run the generator and get something that doesn't match, that's a bug worth filing — the whole point is that it can be checked.

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