[\![36,\,2,\,3]\!] factory

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

As monomials: 0+1 (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 and 4 \mathrm{CZ} gates: \mathrm{S}^\dagger on output 0, \mathrm{S} on output 1, \mathrm{Z} on check 5, \mathrm{Z} on check 7, \mathrm{S}^\dagger on check 8, \mathrm{CZ} on output 0, check 5, \mathrm{CZ} on output 0, check 7, \mathrm{CZ} on check 5, check 8, \mathrm{CZ} on check 7, check 8. 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 \mathrm{T}^3 on rotations 3, 8, 14, 15, 21, 26, 30, 31, 32, 33, 34, 35; \mathrm{T}^\dagger on rotations 0, 1, 4, 5, 18, and \mathrm{T} on the rest. 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/36.2.3.c.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-36.2.3.c.txt", "w") as out:
    out.write("\n".join(lines) + "\n")

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

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

A damaging fault of weight 3 sits on columns [0,10,11].

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

• A. Wills, S. P. Jain, and S. Singh, "Classification of Generalised Triorthogonal Codes through Length 54," arXiv:2609.30860 (2026). arxiv.org/abs/2609.30860
• S. P. Jain, A. Wills, and S. Singh, "Symmetry and AI-assisted discovery of magic-state factories," arXiv:2610.06535 (2026). arxiv.org/abs/2610.06535

found within the exhaustive classification through length 54 but not one of its Pareto points: a Pareto point with the same output class (after removing spectator outputs) and the same exact distance strictly dominates it, which tests/test_master_catalog.py checks -- a verified witness, not an optimum

Found by: exhaustive classification n<=54 AI search

Discovery: pre-existing

[
 {
  "regime": "exhaustive classification n<=54",
  "file": "classification/legacy/exhaustive_n38/catalog/classification_n38.json",
  "label": "0+1",
  "N": 9,
  "d": 3,
  "d_is_exact": true,
  "origin": null,
  "provenance": "quotient_catalog_k3"
 },
 {
  "regime": "AI search",
  "file": "master_catalog/catalogue_new",
  "label": "T0.T1",
  "N": 9,
  "d": 3,
  "d_is_exact": true,
  "origin": "frontier_campaign",
  "provenance": "frontier_campaign \u00b7 catalogue.jsonl:101"
 },
 {
  "regime": "exhaustive classification n<=54",
  "file": "classification/legacy/rank7_census/catalog/sk_classes_r7.json",
  "label": "0+1",
  "N": 9,
  "d": 3,
  "d_is_exact": true,
  "origin": null,
  "provenance": "RM(3,7) orbit class 1350, origin 3; census_shard_09.json"
 },
 {
  "regime": "exhaustive classification n<=54",
  "file": "classification/legacy/exhaustive_n38/catalog/classification_n38.json",
  "label": "0+01",
  "N": 9,
  "d": 3,
  "d_is_exact": true,
  "origin": null,
  "provenance": "quotient_catalog_k3"
 },
 {
  "regime": "AI search",
  "file": "master_catalog/catalogue_new",
  "label": "T0.CS01",
  "N": 9,
  "d": 3,
  "d_is_exact": true,
  "origin": "frontier_campaign",
  "provenance": "frontier_campaign \u00b7 catalogue.jsonl:100"
 },
 {
  "regime": "exhaustive classification n<=54",
  "file": "classification/legacy/rank7_census/catalog/sk_classes_r7.json",
  "label": "0+01",
  "N": 9,
  "d": 3,
  "d_is_exact": true,
  "origin": null,
  "provenance": "RM(3,7) orbit class 1350, origin 3; census_shard_09.json"
 }
]

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/36.2.3.c.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[96].