About the QEC Competition

The Challenge

Quantum computers need error correction to work reliably. Physical qubits are noisy, so we encode logical qubits using surface codes — 2D lattices of physical qubits with redundancy that lets us detect and correct errors.

A decoder is the algorithm that reads error syndrome measurements and decides which corrections to apply. The industry standard is MWPM (Minimum Weight Perfect Matching), which assumes errors are independent. But real quantum hardware has correlated noise — errors that cluster together — and MWPM doesn't exploit this structure.

Your goal: build a decoder that beats MWPM by exploiting correlated noise patterns on surface codes.

What You Submit

A single Python file (.py) that defines one function:

def build_decoder(point: ParameterPoint) -> Decoder:
    """Return a decoder for the given parameter point.

    point.L  -- code distance (3, 5, or 7)
    point.p  -- physical error rate (0.005 or 0.01)
    point.xi -- correlation length (0, 2, 5, or 10)
    """
    return MyDecoder(point)

Your Decoder must implement decode(syndrome_array) where the input is a (shots, num_detectors) uint8 array and the output is a (shots,) uint8 array of predicted logical corrections.

Allowed imports: numpy, scipy, pymatching, stim. No file I/O, no network access, no subprocess calls.

How Evaluation Works

Your decoder is tested on 24 parameter points — every combination of:

• Code distance L: 3, 5, 7
• Error rate p: 0.005, 0.01
• Correlation length xi: 0, 2, 5, 10

At each point, we generate syndrome data using Stim surface code circuits with correlated Bernoulli noise, run your decoder, and count logical errors. Each submission is evaluated with a unique random seed.

Scoring

Your score is errors per million simulations (lower is better):

score = total_errors * 1,000,000 / total_shots

All 24 parameter points are aggregated — total errors across all points divided by total shots across all points. This means harder parameter points (higher p, higher xi, larger L) contribute more to the score.

The MWPM Baseline

The baseline is Minimum Weight Perfect Matching, the most widely used QEC decoder. MWPM finds minimum-weight corrections by modeling errors as a graph matching problem. It works well for independent noise (xi=0) but ignores error correlations.

As xi increases (more correlated noise), MWPM's performance degrades because it treats each error independently. Your decoder can beat it by learning or exploiting the spatial correlation structure of errors.

Anti-Cheat Validation

Submissions are validated with a 7-layer pipeline:

1. File size check (max 200KB)
2. AST parsing — rejects disallowed imports (os, subprocess, socket, etc.)
3. Rejects dangerous builtins (open, exec, eval, compile, __import__)
4. Structural check — must define build_decoder(point)
5. Return type check — decoder must have decode() method
6. Smoke test with hard 2.5s timeout (L=3, p=0.01, xi=0, 100 shots)
7. Random seeds — each evaluation uses a unique seed

Rules & Constraints

• One .py file, max 200KB
• Must define build_decoder(point)
• Allowed: numpy, scipy, pymatching, stim
• No file I/O, network, or subprocess
• 2.5-second hard time limit per parameter point — exceeding the limit kills the process and scores that point as all-wrong
• Rate limit: 1 submission per 10 minutes
• Sign in with X to submit