[\![2811,\,5,\,2]\!] factory

As gates: \mathrm{T}_{0}\cdot \mathrm{T}_{1}\cdot \mathrm{T}_{2}\cdot \mathrm{T}_{3}\cdot \mathrm{T}_{4}

As monomials: 0+1+2+3+4 (output wires per term, separated by +)

This row stands for every gate that a CNOT circuit and S, Z and CZ gates on the outputs can reach from this one. They all prepare the same magic state. The wires are shown in the S_k-canonical frame.

With every rotation a \mathrm{T}=\mathrm{diag}(1,e^{i\pi/4}), the rotations deposit the gate above times a diagonal Clifford. Undo it after the rotations and before the checks are measured, with 5 single-wire gates: \mathrm{S} on output 0, \mathrm{S} on output 1, \mathrm{S} on output 2, \mathrm{S} on output 3, \mathrm{S} on output 4. The circuit's action is then exactly the gate above, and an error-free run passes every check with certainty.

Or no Clifford gate at all: run every rotation as \mathrm{T}^\dagger. A power of \mathrm{T} costs one magic state, like \mathrm{T} itself. For a code this is a transversal \mathrm{T} gate, \mathrm{T}^j on each qubit.

Rotations are numbered by matrix column, from 0. The correction comes from the columns by the weight expansion of Bravyi and Haah (2012). verify_catalog.py re-derives it, checks the corrected circuit's phase input by input against the gate, and on small circuits simulates it gate by gate.

A CNOT circuit on the outputs, followed by S, Z and CZ gates, turns this factory's gate into other gates that prepare the same magic state. Type a target gate to check whether it is reachable. If it is, you get the circuit, checked on every basis state.

import json, urllib.request

NAMES = {1: "T", 2: "CS", 3: "CCZ"}


def equivalent_gates(k, terms, limit=1_000_000):
    """Every gate a CNOT circuit and S, Z, CZ gates reach from this one.

    A gate is its set of terms mod Clifford: {a} is T, {a,b} is CS and
    {a,b,c} is CCZ on those outputs. CNOT c->t sends x_t to
    x_c + x_t - 2 x_c x_t, so a term on t but not c adds the term with t
    replaced by c, and, below CCZ, the term with c added.
    """
    start = frozenset(frozenset(m) for m in terms)
    seen, queue = {start}, [start]
    for gate in queue:
        for c in range(k):
            for t in range(k):
                if c == t:
                    continue
                new = set(gate)
                for m in gate:
                    if t in m and c not in m:
                        new ^= {(m - {t}) | {c}}
                        if len(m) < 3:
                            new ^= {m | {c}}
                new = frozenset(new)
                if new not in seen:
                    seen.add(new)
                    queue.append(new)
                    if len(seen) > limit:
                        raise RuntimeError(f"more than {limit} equivalent gates")
    return seen


def name(gate, k):
    sep = "," if k > 10 else ""
    terms = sorted((sorted(m) for m in gate), key=lambda m: (len(m), m))
    return "·".join(NAMES[len(m)] + sep.join(map(str, m)) for m in terms) or "I"


url = "https://shubhamj810.github.io/magic-state-factory-repo/data/factories/2811.5.2.a.json"
record = json.load(urllib.request.urlopen(url))
k = record["parameters"]["k"]
gates = equivalent_gates(k, record["gate"]["monomials"])
lines = sorted(name(g, k) for g in gates)
print(len(lines), "equivalent gates")
with open("equivalent-gates-2811.5.2.a.txt", "w") as out:
    out.write("\n".join(lines) + "\n")

d=2, exact. No fault of weight below 2 is both undetectable and damaging. One of weight 2 is.

Exactly 6,390 faults of weight 2 are undetectable and damaging, so A_{2}=6{,}390. If each rotation fails independently with probability p, an accepted run has a damaged output with probability A_{2}\,p^{2}+O(p^{3}).

A damaging fault of weight 2 sits on columns [0,256].

A fault is a set of faulty columns. It is undetectable when their check parts cancel, and damaging when their output parts do not.

S. Singh, C. Gidney, and C. Jones, "Borrowed Identities: Malleable Distillation Factories and a Unified Numerical Search," arXiv:2606.28518 (2026). arxiv.org/abs/2606.28518

found by the two-group borrowed-identity search of Singh, Gidney and Jones (arXiv:2606.28518; borrowed_identities/): an identity circuit symmetric within its output and check blocks, with its output-only gates removed; a verified witness, not a maximum

Found by: borrowed-identity search: two-group

Discovery: pre-existing

[
 {
  "regime": "borrowed-identity search: two-group",
  "file": "borrowed_identities/circuits/unified_l3.json",
  "label": "ls-0806",
  "N": 14,
  "d": 2,
  "d_is_exact": true,
  "origin": "https://github.com/shraggy/Magic_state_factory_search at 4627014, outputs/large_sweep.csv line 806",
  "provenance": "unified search l=3, two-group s_total=2,s_O=3"
 }
]

Load this factory and re-derive every number from its circuit with the catalogue's own verifier.

# git clone https://github.com/shubhamj810/magic-state-factory-repo
# cd magic-state-factory-repo/master_catalog
import json, urllib.request
import verify_catalog as VC

url = "https://shubhamj810.github.io/magic-state-factory-repo/data/factories/2811.5.2.a.json"
record = json.load(urllib.request.urlopen(url))
columns = record["circuit"]["columns"]
k, N = record["parameters"]["k"], record["parameters"]["N"]

facts, problems = VC.derive(columns, k, N)    # gate, T-count, degree, ...
distance = VC.measure_distance(columns, k, N)  # exhaustive fault search
print(facts["gate_human"], distance["d_exact"] or distance["d_at_least"],
      problems or "verified")

Source: master_catalog.json, factories[1463].