Dyadic Phase Fixing in Quantum Compilation

• Dyadic Phase Fixing (DPF) is a method that fixes quantum rotation angles to dyadic values to enable more efficient fault-tolerant synthesis.
• It employs greedy multi-qubit resynthesis with numerical reoptimization and phase kickback to reduce resource-intensive T gate usage.
• A catalyst-based variant implements exact dyadic rotations by reusing logical catalyst states, trading increased ancilla overhead for constant online depth.

Searching arXiv for the specified papers and closely related work to ground the article. {"query":"id:(Kalloor et al., 3 Jun 2026) OR id:(Xu et al., 25 Jun 2026)", "max_results": 10} I found the two focal papers on arXiv and verified their metadata:

1. "Multi-Qubit Dyadic Phase Fixing for Fault-Tolerant Quantum Compilation" (Kalloor et al., 3 Jun 2026)
2. "Cultivating logical catalysts for fault-tolerant dyadic phase rotations" (Xu et al., 25 Jun 2026)

I’ll use these as the primary sources for the encyclopedia entry, with terminology and claims constrained to the supplied data. Dyadic Phase Fixing (DPF) names two closely related developments in fault-tolerant quantum computing. In quantum compilation, it denotes a general multi-qubit synthesis routine that greedily fixes selected $R_z$ parameters to dyadic values of the form $m\pi/2^k$, numerically reoptimizes the remaining parameters, and then implements the fixed rotations by phase kickback (Kalloor et al., 3 Jun 2026). In fault-tolerant gate construction, the same basic objective appears in a more specialized form: exact implementation of fixed fine dyadic phases $Z^{2^{-b}}$ by cultivating reusable logical catalyst states that are eigenstates of high-period Clifford circuits and invoking them through controlled-$U$ phase kickback (Xu et al., 25 Jun 2026). The unifying theme is to replace repeated approximate non-Clifford synthesis with dyadic-phase structure that can be exploited exactly or more cheaply, subject to nontrivial tradeoffs in ancillas, serialization, catalyst size, and hardware mapping.

1. Problem setting and conceptual scope

Fault-tolerant quantum computation in the setting considered is organized around the Clifford+$T$ gate set, where Clifford gates are comparatively easy to realize and $T$ gates dominate resource cost because they typically require magic-state cultivation or distillation, injection, and correction (Kalloor et al., 3 Jun 2026). Application circuits, however, are usually expressed with continuous-parameter gates such as $R_z(\theta)$, $R_x(\theta)$, and $U3(\phi,\theta,\lambda)$, so arbitrary rotations must be approximated in a discrete logical basis, usually with cost scaling like $O(\log(1/\epsilon))$ for target precision $m\pi/2^k$0 (Kalloor et al., 3 Jun 2026).

DPF addresses a special regime in which dyadic-angle structure can be exploited. The compiler-oriented formulation targets rotations

$m\pi/2^k$1

for which phase kickback can be dramatically cheaper in $m\pi/2^k$2-count than independent ancilla-free synthesis (Kalloor et al., 3 Jun 2026). The fault-tolerant catalyst formulation isolates the fixed-phase family

$m\pi/2^k$3

so that $m\pi/2^k$4, $m\pi/2^k$5, and more generally a fine dyadic phase rotation is $m\pi/2^k$6 (Xu et al., 25 Jun 2026).

The two formulations differ in scope. The compiler formulation is approximate overall: it rewrites general multi-qubit circuit blocks under a prescribed error budget, fixes some angles to dyadic values, and leaves the remaining arbitrary rotations to conventional synthesis (Kalloor et al., 3 Jun 2026). The catalyst formulation is exact for the target dyadic phase once the phase-specific logical resource has been cultivated: the online invocation introduces no synthesis approximation error and makes the online non-Clifford depth independent of the target logical accuracy (Xu et al., 25 Jun 2026). This suggests that DPF is best viewed not as a single algorithm but as a design principle for converting dyadic phase structure into fault-tolerant advantage.

2. Compiler-level DPF as greedy multi-qubit resynthesis

The compiler introduced in "Multi-Qubit Dyadic Phase Fixing for Fault-Tolerant Quantum Compilation" (Kalloor et al., 3 Jun 2026) proceeds in three stages. First, an input logical circuit in any gate set is retargeted to blocks containing Clifford gates and continuous $m\pi/2^k$7 gates, using non-overlapping partitions of width $m\pi/2^k$8, with $m\pi/2^k$9 in the reported experiments. Second, DPF is applied blockwise. Third, the resulting circuit is decomposed into Clifford+$Z^{2^{-b}}$0 using phase kickback for fixed dyadic rotations and \texttt{gridsynth} for the remaining non-dyadic rotations.

The key operation is “fixing” a phase. Given a candidate block $Z^{2^{-b}}$1 and block error budget $Z^{2^{-b}}$2, DPF maintains a set of accepted candidates $Z^{2^{-b}}$3 and target unitary $Z^{2^{-b}}$4. It then iterates over dyadic granularities

$Z^{2^{-b}}$5

For each candidate circuit $Z^{2^{-b}}$6, it collects the currently unfixed $Z^{2^{-b}}$7 angles and chooses the pair minimizing

$Z^{2^{-b}}$8

The selected gate is replaced by $Z^{2^{-b}}$9, the remaining continuous parameters are numerically reoptimized against the original target unitary, and the candidate is accepted only if the Hilbert-Schmidt-distance test remains within $U$0 (Kalloor et al., 3 Jun 2026).

This is a greedy, heuristic approximate-synthesis strategy rather than an exhaustive search. What is optimized locally is proximity to a dyadic angle; preservation of the block unitary is enforced afterward by numerical reoptimization and acceptance testing. The outcome is operationally a decomposition into many dyadic-angle $U$1 rotations, a smaller residual set of arbitrary-angle $U$2 rotations, and the inherited Clifford structure of the block. The paper explicitly notes that DPF may miss better dyadic rewritings and does not provide formal optimality guarantees for the greedy extraction (Kalloor et al., 3 Jun 2026).

Error management is blockwise. If the circuit is divided into $U$3 blocks, each receives error budget $U$4, and the full algorithm error satisfies

$U$5

Residual arbitrary-angle $U$6 gates are finally synthesized with \texttt{gridsynth} to precision $U$7, where $U$8 is the number of remaining arbitrary-angle rotations (Kalloor et al., 3 Jun 2026).

3. Phase-kickback infrastructure, decision logic, and ancilla tradeoffs

The compilation framework uses phase kickback through a phase gradient register, prepared following Sanders et al., together with constant-adder circuits from Gidney’s construction (Kalloor et al., 3 Jun 2026). For dyadic approximation at denominator scale $U$9, the adder cost scales roughly as $T$0 $T$1 gates, and the ancilla requirement is substantial: $T$2 qubits for the phase gradient register and $T$3 scratch qubits for the optimal adder, for total ancilla overhead $T$4 (Kalloor et al., 3 Jun 2026).

A central implementation choice is to use a single shared phase kickback register of width $T$5 across the recomposed circuit. This prevents ancilla blow-up when many independently synthesized blocks are recombined, but it also serializes the phase-kickback subcircuits (Kalloor et al., 3 Jun 2026). That serialization becomes important at the architecture level because it can degrade depth parallelism even when logical $T$6-count improves.

The compiler therefore uses a three-variable decision matrix parameterized by phase gradient register size $T$7, the number of fixed $T$8 gates that would use that $T$9, and the per-gate approximation error. It compares the exact \texttt{gridsynth} $T$0-count model against a phase-kickback model consisting of phase gradient state preparation plus Gidney-adder cost, sweeps over $T$1, and chooses $T$2 that minimizes predicted total $T$3-count (Kalloor et al., 3 Jun 2026). If no register size yields benefit, the workflow falls back entirely to \texttt{gridsynth}. The paper states this as a practical guarantee: in terms of $T$4-count, the compiler will never do worse than the baseline \texttt{gridsynth} approach (Kalloor et al., 3 Jun 2026).

This logic sharply distinguishes DPF from naive phase kickback. The paper reports that naive phase kickback is generally $T$5 to $T$6 worse than default synthesis except on QFT, because directly approximating arbitrary rotations by dyadic angles often requires large $T$7, which increases register, adder, and ancilla cost (Kalloor et al., 3 Jun 2026). DPF’s contribution is therefore not merely to apply phase kickback, but to use multi-qubit numerical resynthesis to create more phase-kickback-friendly circuit structure.

4. Reported performance and architecture-level evaluation

The benchmark suite for the compiler formulation spans quantum subroutines, chemistry, physics simulation, optimization, and quantum machine learning, with circuit sizes ranging from $T$8 to $T$9 qubits and algorithmic error thresholds $R_z(\theta)$0 and $R_z(\theta)$1 (Kalloor et al., 3 Jun 2026). Preprocessing uses PyTKet Full Peephole Optimization, followed by BQSKit-FT-based compilation and then DPF.

The headline synthesis results are up to $R_z(\theta)$2 reduction in $R_z(\theta)$3-count compared to \texttt{gridsynth} and up to $R_z(\theta)$4 compared to Repeat-Until-Success synthesis (Kalloor et al., 3 Jun 2026). The largest gains are reported for Hamiltonian simulation, QFT, QAE, QAOA, and QPE, where partitions tend to contain enough $R_z(\theta)$5 rotations that DPF can fix many angles to dyadic values and amortize phase-kickback startup cost. At the same time, the method is not uniformly beneficial: KNN is identified as a case with little or no benefit because DPF could not extract enough dyadic angles to justify phase kickback (Kalloor et al., 3 Jun 2026).

The paper also maps compiled circuits to a surface-code architecture using lattice surgery and evaluates space-time volume,

$R_z(\theta)$6

under two Pauli-basis compilation strategies: Lightweight Pauli Basis Computation (LPBC) and Heavyweight Pauli Basis Computation (HPBC) (Kalloor et al., 3 Jun 2026). The reported improvement reaches up to $R_z(\theta)$7 in space-time volume, with QAE-81q under HPBC improving from $R_z(\theta)$8 to $R_z(\theta)$9 and Ising-420q improving from $R_x(\theta)$0 to $R_x(\theta)$1 under LPBC/HPBC. Other strong HPBC improvements include QFT-40q from $R_x(\theta)$2 to $R_x(\theta)$3, LGT-380q from $R_x(\theta)$4 to $R_x(\theta)$5, and Neutrino-18q from $R_x(\theta)$6 to $R_x(\theta)$7 (Kalloor et al., 3 Jun 2026).

The same evaluation also shows substantial regressions. QAE-81q under LPBC worsens from $R_x(\theta)$8 to $R_x(\theta)$9; QPE-14q worsens from $U3(\phi,\theta,\lambda)$0 to $U3(\phi,\theta,\lambda)$1 under LPBC and from $U3(\phi,\theta,\lambda)$2 to $U3(\phi,\theta,\lambda)$3 under HPBC; QAOA-148q under HPBC worsens from $U3(\phi,\theta,\lambda)$4 to $U3(\phi,\theta,\lambda)$5; and Heisenberg-225q under HPBC worsens from $U3(\phi,\theta,\lambda)$6 to $U3(\phi,\theta,\lambda)$7 (Kalloor et al., 3 Jun 2026). The paper’s central interpretation is that $U3(\phi,\theta,\lambda)$8-count is a useful but incomplete proxy for fault-tolerant program cost. Phase kickback can reduce logical non-Clifford count while increasing ancillas, adder CNOTs, serialization through the shared phase gradient register, and routing contention. Under LPBC, adder CNOTs often remain explicit sequential operations; under HPBC, the same Clifford-heavy adders may be absorbed into larger Pauli-product measurements, reducing the depth penalty (Kalloor et al., 3 Jun 2026).

5. Exact dyadic phase fixing by reusable logical catalysts

"Cultivating logical catalysts for fault-tolerant dyadic phase rotations" (Xu et al., 25 Jun 2026) presents a concrete surface-code-compatible framework for what is effectively DPF via reusable logical catalyst states. Rather than approximating a fine dyadic $U3(\phi,\theta,\lambda)$9-rotation with a long Clifford+$O(\log(1/\epsilon))$0 sequence every time it is needed, the protocol prepares a phase-specific logical resource state offline and then reuses it to implement the target dyadic phase exactly by phase kickback (Xu et al., 25 Jun 2026).

The target family is

$O(\log(1/\epsilon))$1

A direct cultivation of the single-qubit magic state $O(\log(1/\epsilon))$2 is obstructed by the Clifford hierarchy for $O(\log(1/\epsilon))$3: for $O(\log(1/\epsilon))$4, the conjugated $O(\log(1/\epsilon))$5 operator remains Clifford-verifiable, but for finer dyadic states the analogous operator is itself non-Clifford, so direct verification would require the same non-Clifford resource one is trying to prepare (Xu et al., 25 Jun 2026).

The workaround is to cultivate a logical catalyst that is an eigenstate $O(\log(1/\epsilon))$6 of a specially chosen high-period Clifford circuit $O(\log(1/\epsilon))$7. Because

$O(\log(1/\epsilon))$8

where $O(\log(1/\epsilon))$9 is the eigenvalue of $m\pi/2^k$00 on $m\pi/2^k$01, the state mediates the phase transformation without being consumed. The paper uses a family of depth-2 brickwork CNOT circuits $m\pi/2^k$02 whose order is a power of two and whose eigenvalues are corresponding roots of unity. For $m\pi/2^k$03, $m\pi/2^k$04 has period $m\pi/2^k$05, and the orbit-state construction

$m\pi/2^k$06

satisfies

$m\pi/2^k$07

Controlled-$m\pi/2^k$08 then kicks back the exact phase $m\pi/2^k$09, so choosing $m\pi/2^k$10 and $m\pi/2^k$11 implements $m\pi/2^k$12 exactly (Xu et al., 25 Jun 2026).

For arbitrary $m\pi/2^k$13, the smallest direct brickwork construction uses $m\pi/2^k$14, so the catalyst support scales as $m\pi/2^k$15 logical qubits (Xu et al., 25 Jun 2026). This is the central asymptotic tradeoff: exactness, reusability, and constant online depth are obtained at the price of an exponentially large catalyst register in $m\pi/2^k$16.

The paper’s worked example is $m\pi/2^k$17, corresponding to $m\pi/2^k$18. Here $m\pi/2^k$19 and $m\pi/2^k$20, and the nine-qubit brickwork Clifford $m\pi/2^k$21 has period $m\pi/2^k$22. One representative catalyst is

$m\pi/2^k$23

The $m\pi/2^k$24 eigenspace is $m\pi/2^k$25-fold degenerate, and the paper notes that this degeneracy is harmless for catalytic use because only the eigenphase matters. Online invocation requires controlled-$m\pi/2^k$26, which contains eight controlled-CNOTs, i.e. eight Toffolis. The reported costings are $m\pi/2^k$27 $m\pi/2^k$28 gates for a conservative unitary Clifford+$m\pi/2^k$29 implementation, $m\pi/2^k$30 $m\pi/2^k$31 gates using measurement-assisted logical-ANDs, or consumption of $m\pi/2^k$32 $m\pi/2^k$33 states in parallel (Xu et al., 25 Jun 2026).

6. Cultivation protocol, verification theory, and comparative tradeoffs

The catalyst-cultivation protocol begins from a physical $m\pi/2^k$34-qubit catalyst on the $m\pi/2^k$35 orbit, encodes each qubit into an independent distance-3 rotated surface-code block, verifies the encoded catalyst by logical quantum phase estimation of $m\pi/2^k$36, postselects on trivial syndromes, and then grows the code distance up to distance $m\pi/2^k$37 (Xu et al., 25 Jun 2026). Since the target eigenvalue is $m\pi/2^k$38, four ancilla bits suffice. One logical-$m\pi/2^k$39 measurement round applies

$m\pi/2^k$40

with compressed schedules for $m\pi/2^k$41, $m\pi/2^k$42, and $m\pi/2^k$43; the reported CNOT counts are $m\pi/2^k$44, with $m\pi/2^k$45. The accepted semiclassical inverse-QFT output string is $m\pi/2^k$46 (Xu et al., 25 Jun 2026).

A crucial technical point is that the phase readout is an exact projector onto the desired eigenspace. For the accepted string $m\pi/2^k$47, the readout operator is

$m\pi/2^k$48

which is exactly the projector onto the $m\pi/2^k$49 eigenspace (Xu et al., 25 Jun 2026). Because $m\pi/2^k$50 has exact period $m\pi/2^k$51, there is no spectral leakage: faults that move the state to a different eigenphase sector are ideally detected by phase estimation. The paper studies every single-qubit Pauli fault on the physical $m\pi/2^k$52 under ideal phase estimation and finds that the only undetected single-qubit faults are $m\pi/2^k$53 and $m\pi/2^k$54, both acting merely as a global phase. The average Hamming distance from $m\pi/2^k$55 of the flagged readout is $m\pi/2^k$56, giving effective logical fault distance $m\pi/2^k$57. Once the later stabilizer-growth stage provides $m\pi/2^k$58, the decoded logical leakage scales as $m\pi/2^k$59. This is the sense in which a single logical verification round already reaches the leading error-corrected scaling (Xu et al., 25 Jun 2026).

After verification, the protocol performs noisy distance-3 stabilizer extraction on every $m\pi/2^k$60 block with hard postselection on all-zero syndrome, followed by growth $m\pi/2^k$61, repeated trivial-syndrome postselection, unitary growth to $m\pi/2^k$62, and final stabilizer-measurement growth $m\pi/2^k$63 (Xu et al., 25 Jun 2026). In the last stage, acceptance is based on complementary-gap decoding between the best and second-best logical Pauli-frame hypotheses, and the final cultivated catalyst carries an $m\pi/2^k$64-bit decoded Pauli frame.

The error metric is logical leakage out of the desired eigenspace rather than Pauli-frame error. For each accepted shot, the logical fidelity is computed after applying the residual decoded Pauli frame and projecting onto the $m\pi/2^k$65 eigenspace, with leakage rate $m\pi/2^k$66 (Xu et al., 25 Jun 2026). The simulation is hybrid: the front end is simulated as a tensor-network/MPS state vector using iTensor, the back end with Stim and PyMatching, the front-end noise model is circuit-level depolarizing noise at physical rate $m\pi/2^k$67, and the main reported results use $m\pi/2^k$68 with MPS bond dimension $m\pi/2^k$69. Quantitatively, the paper reports that at $m\pi/2^k$70, a single logical-$m\pi/2^k$71 verification round together with suitable distance-3 syndrome postselection and distance-7 growth yields logical leakage around $m\pi/2^k$72 using about $m\pi/2^k$73 to $m\pi/2^k$74 expected attempts, while stronger complementary-gap postselection pushes the leakage toward $m\pi/2^k$75 (Xu et al., 25 Jun 2026).

The two DPF formulations are complementary rather than redundant.

Aspect	Compiler DPF	Catalyst-based exact dyadic rotation
Primary object	General multi-qubit circuit blocks	Fixed fine dyadic phases $m\pi/2^k$76
Core mechanism	Greedy dyadic fixing plus numerical reoptimization	Reusable logical catalyst eigenstate of Clifford $m\pi/2^k$77
Exactness	Approximate overall	Exact online dyadic phase
Main overhead	Shared-register ancillas and serialization	Catalyst size $m\pi/2^k$78
Key caution	$m\pi/2^k$79-count and space-time volume can diverge	Offline cultivation is angle-specific

This comparison clarifies several common misunderstandings. DPF is not synonymous with exact dyadic gate realization: in the compiler sense it is explicitly a heuristic approximate-synthesis method (Kalloor et al., 3 Jun 2026). Conversely, exact dyadic phase fixing is not automatically qubit-efficient: the catalyst construction achieves exactness and reusability at support cost $m\pi/2^k$80 (Xu et al., 25 Jun 2026). The papers also converge on a broader caution about cost models. In the compiler setting, lower $m\pi/2^k$81-count can worsen mapped space-time volume because of ancillas, adder structure, and serialization (Kalloor et al., 3 Jun 2026). In the catalyst setting, constant-depth exact online implementation is purchased by substantial offline, phase-specific cultivation (Xu et al., 25 Jun 2026). A plausible implication is that DPF techniques are most compelling when the same modestly fine dyadic phase or dyadic-rich block structure is reused often enough to amortize either compilation infrastructure or catalyst preparation.