[\![559,\,1,\,6]\!] factory

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

As monomials: 0 (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 1 single-wire gate: \mathrm{S} on output 0. 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/559.1.6.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-559.1.6.a.txt", "w") as out:
    out.write("\n".join(lines) + "\n")

6\le d\le 15. No fault of weight below 6 is both undetectable and damaging. None of weight 6 has been found, and one of weight 15 is, so the distance lies between the two.

A damaging fault of weight 15 sits on columns [0,79,158,223,288,335,382,423,464,487,510,527,544,551,558].

Its source certifies d\ge 15, as a lower bound. That certificate is not re-checked here, but rankings on this site may use it. With the damaging fault of weight 15 above, it makes the distance exactly d=15. Source: A. Gong (github.com/gongaa/RM127, triply-even/): [[79,1,15]] quantum QR code (extended QR [80,40,16]) doubled onto [[401,1,13]]; the doubling theorem (Jain and Albert, arXiv:2408.12752, Sec. III) gives d >= min(d_sd, d_tri + 2) = 15; the distances of Gong's self-dual [[41,1,9]] and [[65,1,13]] codes are proved here by enumerating every word of their stabiliser spaces.

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. Gong, "On some K=1 codes admitting strongly transversal T," note in the RM127 repository, triply-even/ (2025). github.com/gongaa/RM127/tree/main/triply-even

a code of the triply even family of A. Gong (note in github.com/gongaa/RM127, triply-even/; transversal_t_codes/): her doubly even self-dual [[41,1,9]] and [[65,1,13]] codes and quantum QR codes doubled onto [[95,1,7]], rebuilt here from her self-dual codes, where T on every qubit is a logical T or T-dagger; a verified witness, not a maximum

Found by: Gong doubling: triply even family

Discovery: pre-existing

[
 {
  "regime": "Gong doubling: triply even family",
  "file": "transversal_t_codes/factories.json",
  "label": "G-559",
  "N": 144,
  "d": 6,
  "d_is_exact": false,
  "origin": "A. Gong, \"On some K=1 codes admitting strongly transversal T\", note in github.com/gongaa/RM127, triply-even/ (2025)",
  "provenance": "[[79,1,15]] quantum QR code (extended QR [80,40,16]) doubled onto [[401,1,13]] (Gong's note)"
 }
]

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/559.1.6.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[1129].