Magic-Friendly Triples in Quantum CSS Codes

• Magic-friendly triples are algebraic and combinatorial constructs in CSS quantum codes that satisfy strict orthogonality and parity conditions to enable logical CCZ gates.
• The hypergraph circuit model and packing lemma ensure that these triples can be implemented in constant depth, optimizing resource scaling and fault tolerance.
• In tricycle codes, magic-friendly triples facilitate native magic-state generation with single-shot error correction, significantly reducing space–time overhead.

Magic-friendly triples are an algebraic and combinatorial construct central to the design of quantum CSS codes that natively support constant-depth, high-throughput non-Clifford resource state generation—specifically, logical $\mathrm{CCZ}$ (controlled-controlled-$Z$) gates in qLDPC (quantum low-density parity-check) codes. The existence, distribution, and implementation of magic-friendly triples underpins magic-state factories that dramatically reduce the space–time overhead associated with universal quantum computation, by producing many resource states (such as CCZ magic states) in parallel and without multi-round distillation.

1. Algebraic Definition and Criteria of Magic-Friendly Triples

A magic-friendly triple is defined within the structure of a CSS code specified by two binary linear codes $(C_X, C_Z \subset \mathbb{F}_2^n)$, with $C_Z \subseteq C_X^\perp$. The logical $X$ operators are represented as

$\mathcal{L}_X = C_Z^\perp / C_X,$

where $$C_Z^\perp = \{v \in \mathbb{F}_2^n : v \cdot w = 0 \;\forall w \in C_Z\}$$. A triple of logical $X$ operators $(x, y, z) \in (C_Z^\perp)^3$ is magic-friendly if the following hold (Rowshan, 30 Jan 2026):

• Their images in $\mathcal{L}_X$ are linearly independent (each corresponds to a distinct logical qubit).
• They satisfy pairwise orthogonality:

$$x \cdot y = x \cdot z = y \cdot z = 0 \;(\bmod\;2),$$

• The triple overlap is odd:

$$\tau(x, y, z) = \sum_{i=1}^{n} x_i y_i z_i \;(\bmod\;2) = 1,$$

which guarantees that a transversal layer of $\mathrm{CCZ}$ gates on corresponding qubits induces a nontrivial diagonal logical $\mathrm{CCZ}$ on these logical qubits.

This definition ensures that each magic-friendly triple is not only algebraically valid for non-Clifford transformations but also implements them in a manner that is compatible with the error-correction structure of qLDPC codes.

2. Hypergraph Circuit Model and Depth Optimization

The physical implementation of logical $\mathrm{CCZ}$ operations corresponding to magic-friendly triples is modeled as a bounded-degree 3-uniform hypergraph $H = (V, E)$, where $V = [n]$ is the set of physical qubits and each edge $e \in E$ corresponds to a $CCZ$ gate acting on a triple of qubits. The depth of the circuit is controlled by edge-coloring:

• If the maximum degree at any qubit is $\Delta$, then the circuit can be scheduled in at most $3\Delta + 1$ layers so that no qubit participates in more than one gate per layer (Rowshan, 30 Jan 2026).
• For tricycle codes, every qubit participates in $18$ $\mathrm{CCZ}$ gates, organized in two layers of $9$ each (Menon et al., 14 Aug 2025).

This combinatorial approach guarantees that the full pack of logical $\mathrm{CCZ}$ gates arising from a collection of magic-friendly triples can be physically realized in constant depth while maintaining the LDPC property and code distance.

3. Packing Lemma and Distribution of Supports

Given a collection $S$ of magic-friendly triples, efficient utilization requires that individual physical qubits are not overused—meaning their support is distributed. The packing lemma formalizes this:

• Let each triple $t = (x_t, y_t, z_t)$ have support $$S_t = \mathrm{supp}(x_t) \cup \mathrm{supp}(y_t) \cup \mathrm{supp}(z_t)$$, with $a n \leq |S_t| \leq b n$ for constants $a,b$.
• If each qubit participates in at most $M$ supports, one can greedily extract a subcollection $T \subseteq S$ such that supports in $T$ are pairwise disjoint and $|T| \geq |S|/(M b n)$ (Rowshan, 30 Jan 2026).

This packing enables simultaneous implementation of many logical $\mathrm{CCZ}$ gates in parallel, regulated by combinatorial bounds on qubit participation.

4. Magic-Friendly Triples in Tricycle Codes

Tricycle codes are a specific instance of CSS qLDPC codes structured as balanced products of three group-algebra codes over a finite Abelian group $G$ of order $n_G$. The quantum parity-check matrices for $N = 3 n_G$ qubits are: $$H_X = [\mathbf{A}^T\,\mathbf{B}^T\,\mathbf{C}^T], \qquad H_Z = \begin{bmatrix} \mathbf{C} & 0 & \mathbf{A}\ 0 & \mathbf{C} & \mathbf{B}\ \mathbf{B} & \mathbf{A} & 0 \end{bmatrix},$$ where each $\mathbf{A}, \mathbf{B}, \mathbf{C}$ is assembled from permutation matrices associated with group-algebra elements (Menon et al., 14 Aug 2025).

Tricycle codes admit transversal, constant-depth $\mathrm{CCZ}$ gates, and the logical connectivity induced by magic-friendly triples allows for the extraction of up to $K_{CCZ} \leq K$ disjoint logical $\mathrm{CCZ}$ gates per block, directly enabling high-rate magic state generation.

5. Thresholds, Decoding, and Fault-Tolerance

Single-shot state-preparation and fault-tolerant error correction are facilitated by properties intrinsic to magic-friendly triples:

• $X$-type checks act on initial $\ket{+}^{\otimes N}$ states and return deterministic $+1$ syndromes.
• $Z$-type checks are rendered redundant by meta-check relations, permitting single-shot correction via decoders such as Belief-Propagation with Order-Statistics (BP+OSD).
• Circuit-level depolarizing noise models with two-qubit gate error rates $p_{2q}$ confirm robust suppression of logical error rates, with thresholds $p_{\mathrm{th}} \approx 0.4\%$ for codes as large as $N = 648$ (Menon et al., 14 Aug 2025).

A plausible implication is that the space–time overhead for distillation is significantly reduced, as redundancy and packing of magic-friendly triples minimize both error propagation and decoding complexity.

6. Implementation Strategies and Resource Scaling

Magic-friendly triples enable the construction of optimal-depth syndrome extraction circuits:

• For codes where permutation matrices have weight-1 per row/column, all CNOT layers can be scheduled in $w_a + w_b + w_c$ layers (e.g., $12$ for $(4,4,4)$ weights in tricycle codes).
• Implementation on neutral atom arrays takes advantage of sector-wise qubit movement and global pulses, yielding per-syndrome cycle depth $O(12)$ (Menon et al., 14 Aug 2025).

Resource scaling tables for select tricycle codes under $p_{2q}=10^{-3}$:

Code	$p_L^{(Z)}$	$p_L^{(X)}$	$K_{CCZ}$
[[192,27,8]]	$10^{-5}$	$2\times10^{-4}$	$\geq 5$
[[375,15,15]]	$4\times10^{-10}$	$5\times10^{-6}$	$\geq 5$
[[648,18,18]]	$10^{-14}$	$10^{-7}$	$\geq 5$

This suggests the deterministic production of many logical CCZ resource states in one code block with orders-of-magnitude reduction in spatial and temporal overhead compared to multi-level distillation protocols.

7. Structural Theorem and Applications to qLDPC Code Families

The existence of native constant-depth CCZ magic-state fountains in qLDPC code families is governed by the capacity to generate and distribute a large number of magic-friendly triples:

• If a CSS qLDPC family on $n$ qubits admits at least $c_1 n^{1+\gamma}$ magic-friendly triples with supports distributed so that each qubit is used at most $M$ times, then by packing, at least $\frac{c_1}{M b} n^\gamma$ logical CCZ gates can be realized in parallel in constant depth (Rowshan, 30 Jan 2026).
• For quantum Tanner codes and other LDPC constructions, the key combinatorial problem is demonstration of sufficient numbers and distribution of magic-friendly triples in logical $X$ space.

This result eliminates the need for repeated distillation cycles and post-selection: the algebraic presence and combinatorial packing of magic-friendly triples alone ensures the existence of a native magic-state fountain preserving the LDPC properties and linear code distance.

---

Magic-friendly triples thus represent the bridging concept that enables efficient, scalable, and robust magic state generation in leading CSS code architectures, linking algebraic structure, circuit-model combinatorics, and practical implementation protocols for next-generation fault-tolerant quantum computation (Menon et al., 14 Aug 2025, Rowshan, 30 Jan 2026).