Reducing T Gates with Unitary Synthesis

TL;DR

The paper tackles the high overhead of $T$ gates in fault-tolerant quantum computing by introducing trasyn, a tensor-network–based method that directly synthesizes arbitrary single-qubit unitaries in the Clifford+$T$ gate set. By constructing a matrix product state from precomputed gate sequences and performing error-aware sampling guided by the trace distance, trasyn achieves native $U3$ synthesis and reduces both $T$ count and Clifford gate count while maintaining or improving fidelity, compared to $R_z$-based workflows like gridsynth. The authors quantify the gains across 187 circuits and 1000 random unitaries, showing up to 3.5x $T$-count reduction, up to 7x fewer Clifford gates, and up to 4x improvement in overall circuit infidelity; they also analyze the tradeoff between synthesis error and logical error, identifying optimal synthesis thresholds for early FTQC. The work further demonstrates that the approach scales better than brute-force or purely analytical methods and remains competitive with optimized post-synthesis tools, offering a practical pathway toward faster, more scalable FTQC implementations.

Abstract

Quantum error correction is essential for achieving practical quantum computing but has a significant computational overhead. Among fault-tolerant (FT) gate operations, non-Clifford gates, such as $T$, are particularly expensive due to their reliance on magic state distillation. These costly $T$ gates appear frequently in FT circuits as many quantum algorithms require arbitrary single-qubit rotations, such as $R_x$ and $R_z$ gates, which must be decomposed into a sequence of $T$ and Clifford gates. In many quantum circuits, $R_x$ and $R_z$ gates can be fused to form a single $U3$ unitary. However, existing synthesis methods, such as Gridsynth, rely on indirect decompositions, requiring separate $R_z$ decompositions that result in a threefold increase in $T$ count. This work presents TensoR-based Arbitrary unitary SYNthesis (trasyn), a novel FT synthesis algorithm that directly synthesizes arbitrary single-qubit unitaries, avoiding the overhead of separate $R_z$ decompositions. By leveraging tensor network-based search, our approach enables native $U3$ synthesis, reducing the $T$ count, Clifford gate count, and approximation error. Compared to Gridsynth-based circuit synthesis, for 187 representative benchmarks, our design reduces the T count by up to 3.5$\times$, and Clifford gates by 7$\times$, resulting in up to 4$\times$ improvement in overall circuit infidelity.

Figures (14)

• Figure 1: (a) Brute-force enumeration or sampling of gate sequences is slow and unscalable due to the vast search space. (b) Our method trasyn leverages precomputed sequences as building blocks to extend the scale beyond brute force. By incorporating the target unitary and interpreting the error (distance to the target) as probabilities, trasyn enables error-aware sampling, delivering efficiency and accuracy.
• Figure 2: Reduction ratio ($\frac{\textsc{gridsynth}\xspace}{\textsc{trasyn}\xspace}$) for $T$ count, Clifford gates, and infidelity for baseline to our design. Values of more than one indicate our design performs better.
• Figure 3: (a) Compilation workflows for FTQC. The $U3$ IR enables the merging of multiple rotations and can lead to fewer $T$ gates after synthesis. (b) Ratio of $R_z$ to $U3$ gate counts after transpiling 187 benchmark circuits into $CNOT$+$H$+$R_z$ and $CNOT$+$U3$, indicating the effectiveness of $U3$ as IR.
• Figure 4: (a) A matrix drawn in tensor diagram. Each dimension becomes an edge of the tensor node. (b) The trace operation on two matrices is to sum over the two dimensions. (c) A 1D tensor network (MPS) and the equivalent exponentially large tensor.
• Figure 5: An overview of trasyn's core algorithm. (a) Step 0 identifies unique matrices and the associated gate sequence. and stores them as tensors. Squares represent the matrices stacked together, which becomes a 3-dimensional tensor, where the extra dimension indexes the matrices and is our sampling target. (b) To go beyond brute-force enumeration, step 1 connects the tensors to construct an MPS and implicitly traces the target unitary along the matrix dimensions (orange). (c) Sequential contractions and decompositions (denoted in green) are performed to shift the matrix dimensions to the same tensor to perform the trace operation. The same process is repeated toward the left for each pair of tensors. (d) Step 2 samples gate sequences using the trace values as a joint probability distribution $p(X_1,\ldots,X_l)$, where each $X_i$ represents the sequence to choose for each tensor. To compute $p(X_1)$, we sum over $X_2,\ldots,X_l$, which is a contraction with the conjugate transposes, denoted as dashed nodes. (e) We sample a value $x_1$ from $p(X_1)$ and project the first tensor to $x_1$, contract with the second tensor, and repeat the same process to compute $p(X_2|x_1)$. (f) Step 3 further optimizes the sampled gate sequence. Although sequences are prepared to be optimal for each tensor, the concatenation of sequences from multiple tensors can contain suboptimal subsequences with shorter equivalents.