Approximate Quantum Compiling (AQC)

• AQC is a framework that approximates ideal unitaries or states with implementable circuits subject to hardware constraints such as gate sets, connectivity, and error tolerance.
• It employs diverse methods—from exhaustive search and Solovay–Kitaev variants to variational and tensor network strategies—to optimize fidelity and circuit depth.
• AQC adapts to specific hardware conditions (e.g., fault-tolerant, NISQ) by balancing precision with resource limitations, enabling scalable quantum subroutine compression.

Searching arXiv for the cited AQC papers and closely related work. Approximate quantum compiling (AQC) denotes a family of methods that replace an ideal target state, unitary, or circuit by an implementable approximation subject to constraints such as gate alphabet, connectivity, depth, or error tolerance. In the literature considered here, the term spans several distinct but related problem classes: single-qubit synthesis over fault-tolerant gate sets, variational compilation of multi-qubit circuits into shallow hardware-native layouts, tensor-network-assisted state preparation, and compiler-level allocation of approximation error across algorithmic subroutines (Jr, 2012, Madden et al., 2021, Guo et al., 13 Jan 2025, Jaderberg et al., 12 Mar 2025).

1. Scope and problem formulations

AQC has no single canonical formulation. In one important line of work, the target is a single-qubit unitary and the output is a short sequence over a restricted universal set such as Clifford+$T$, or the braid generators of Fibonacci anyons (Jr, 2012, Long et al., 3 Jan 2025). In another, the target is a deep circuit or a target state, and the output is a shallower variational circuit compatible with a particular hardware layout, such as a brick-wall CNOT architecture or a nearest-neighbour 1D circuit (Guo et al., 13 Jan 2025, Jaderberg et al., 12 Mar 2025). A further generalization treats approximation parameters themselves as compiler objects, so that synthesis error, Trotter error, approximate QFT error, and phase-estimation error are optimized jointly under a global accuracy constraint (Meuli et al., 2020).

The variety of targets is central. Some works compile an arbitrary single-qubit $U \in SU(2)$ up to global phase (Jr, 2012). Some compile a target circuit $U_{\rm target}$ into a shallower brick-wall circuit $U_{\rm optim}$ with optimized one-qubit gates and CNOT layers (Guo et al., 13 Jan 2025). Some compile a target MPS or a time-evolved tensor-network state into a short-depth preparation circuit (Robertson et al., 2023, Jaderberg et al., 12 Mar 2025). Some approximate the QPE unitary inside HHL because the exact circuit is too deep for NISQ hardware (Ganeshamurthy et al., 2024). Some compile the state-preparation and payoff-encoding blocks used in amplitude-estimation circuits for energy risk analysis (Ghosh et al., 2023).

Formulation	Target and constraints	Representative papers
Gate synthesis	Single-qubit unitary over Clifford+$T$ or braids	(Jr, 2012, Long et al., 3 Jan 2025)
Variational circuit compression	Deep circuit to shallow brick-wall or CNOT-layout ansatz	(Madden et al., 2021, Guo et al., 13 Jan 2025)
State compilation	MPS or target state to shallow preparation circuit	(Robertson et al., 2023, Jaderberg et al., 12 Mar 2025)
Compiler-level approximation budgeting	Program with symbolic error parameters	(Meuli et al., 2020)
Subroutine compression	QPE/HHL or amplitude-estimation blocks on NISQ hardware	(Ganeshamurthy et al., 2024, Ghosh et al., 2023)

This breadth corrects a common misconception: AQC is not only single-qubit gate synthesis. The papers collectively show that it also includes fixed-input state compilation, module-level compression, and accuracy-aware program compilation.

2. Metrics and objective functions

AQC is organized around explicit approximation metrics. In Fowler-style single-qubit compiling, the distance is the phase-insensitive trace metric

$$\mathrm{dist}(U,U_l)=\sqrt{\frac{2-\left|\mathrm{tr}(UU_l^\dagger)\right|}{2}},$$

which is invariant under global phase and obeys the triangle inequality (Jr, 2012). In Fibonacci-anyon compiling, the paper uses the global-phase-invariant quantity

$$d(U_0,U)=1-\frac{1}{2}\big|\mathrm{Tr}(U_0U^\dagger)\big|,$$

again emphasizing phase insensitivity (Long et al., 3 Jan 2025).

Variational circuit-compilation papers often use Frobenius or Hilbert–Schmidt objectives. “Best approximate quantum compiling” formulates the problem as

$$\min_{V\in\mathcal{V}\subseteq SU(2^n)} \frac{1}{2}\|V-U\|_F^2,$$

with $\mathcal{V}$ determined by the allowed CNOT+rotation architecture and hardware connectivity; the same paper relates this cost to a lower bound on average gate fidelity (Madden et al., 2021). “Sketching the Best Approximate Quantum Compiling Problem” uses the normalized form

$$\frac{1}{2d}\|V-U\|_F^2 = 1-\frac{1}{d}\Re\langle V,U\rangle,$$

with $U \in SU(2)$0, and reports average gate fidelity

$U \in SU(2)$1

as the success criterion (Madden et al., 2022).

State-oriented AQC uses state fidelity directly. AQC-Tensor and ADAPT-AQC adopt

$U \in SU(2)$2

while the Loschmidt-echo formulation in ADAPT-AQC rewrites the same objective as $U \in SU(2)$3 (Jaderberg et al., 12 Mar 2025). The self-navigation algorithm uses Hilbert–Schmidt fidelity between unitaries,

$U \in SU(2)$4

and sets the approximation parameter as $U \in SU(2)$5 (He et al., 2022). Deep-reinforcement-learning compiling uses average gate fidelity as the operative success criterion, with $U \in SU(2)$6 in the reported experiments (Moro et al., 2021). Compiler-level symbolic resource estimation instead propagates operator-norm error bounds of the form $U \in SU(2)$7 through the program structure (Meuli et al., 2020).

No single metric dominates across the literature. This suggests that AQC is best understood as a constrained approximation program whose objective depends on the physical model, the synthesis task, and the downstream resource metric.

3. Search-based and synthesis-oriented methods

The earliest formulation in the present set is Fowler-style approximate compiling over a Steane-code-oriented Clifford+$U \in SU(2)$8 library. There the target is a single-qubit unitary, the search space contains 25 non-identity elementary gates in Fowler’s representation, and the compiler enumerates sequences in canonical order while using a unique-sequence tree to skip redundant subtrees (Jr, 2012). The 2012 optimization paper preserves the exponential worst-case scaling but introduces two constant-factor improvements: a meet-in-the-middle search using a middle structure of suffixes, and a modified Pauli-basis representation in which an $U \in SU(2)$9 unitary is stored as a real four-vector and trace overlap becomes a dot product. The reported empirical gain is one to two orders of magnitude, and the $U_{\rm target}$0 gate is compiled to Fowler distance $U_{\rm target}$1 in about 3 hours and 5 minutes with a 72-gate abstract sequence (Jr, 2012).

The Solovay–Kitaev line remains present, but several papers modify its practical core. The GA-enhanced SKA paper treats the 0-order approximation in Solovay–Kitaev as a search over braid words of Fibonacci anyons and replaces brute force by a genetic algorithm. In that setting, the reported distances $U_{\rm target}$2 for 2nd order with $U_{\rm target}$3 and $U_{\rm target}$4 for 3rd order with $U_{\rm target}$5 are used to argue that longer base searches can reduce final braid length at comparable precision (Long et al., 3 Jan 2025). By contrast, the deep-reinforcement-learning compiler treats single-qubit compiling as a Markov decision process, stores a policy in a neural network, and reports empirical sequence-length scaling close to $U_{\rm target}$6 on the tested task, rather than the larger exponents associated with standard Solovay–Kitaev implementations (Moro et al., 2021).

A distinct synthesis-oriented direction is “best approximate quantum compiling,” which recasts AQC as constrained mathematical programming over fixed CNOT+rotation templates. That paper studies smoothness, Hessian bounds, stationary points, and group-LASSO-style regularization for pruning whole CNOT units; among its concrete outcomes are a 14-CNOT 4-qubit Toffoli decomposition and the claim that Quantum Shannon Decomposition can be compressed by a factor of two without practical loss of fidelity (Madden et al., 2021). “Sketching the Best Approximate Quantum Compiling Problem” keeps the same optimization viewpoint but introduces stochastic and sketch-and-solve variants; within roughly one hour it reports successful compilation of 9-qubit 27-CNOT, 12-qubit 24-CNOT, and 15-qubit 15-CNOT targets, whereas standard optimization in that setting does not scale beyond 9-qubit 9-CNOT circuits (Madden et al., 2022).

These papers collectively establish a central AQC tension: exhaustive or structure-aware search can be close to optimal at small scale, but scalability rapidly becomes the dominant issue.

4. Variational, learning-based, and tensor-network methods

Variational AQC replaces explicit search by a trainable ansatz and a differentiable or sample-based loss. In the reinforcement-learning formulation, the observation is the relative unitary $U_{\rm target}$7 satisfying $U_{\rm target}$8, the action space is the gate alphabet, and the reward is chosen either as a dense function of distance or as a sparse success signal with Hindsight Experience Replay for discrete efficiently universal bases (Moro et al., 2021). The paper emphasizes the offline-training/online-compilation tradeoff: training is expensive, but after training the agent returns each gate in $U_{\rm target}$9 per time-step on a CPU core (Moro et al., 2021).

A hardware-aware single-qubit variant is the self-navigation algorithm. There the allowed controls are rotations about $U_{\rm optim}$0 and a finite set of axes in the $U_{\rm optim}$1-plane realized through a transmon Hamiltonian with virtual $U_{\rm optim}$2 gates. The algorithm iteratively chooses the allowed axis that maximizes the next-step fidelity improvement, and the reported pulse count and classical runtime both scale as $U_{\rm optim}$3 with small prefactors (He et al., 2022). The paper’s central practical claim is that the overall rotation distance generated by the algorithm is significantly shorter than the standard $U_{\rm optim}$4 gate, so the gate time can be shortened in weakly anharmonic systems (He et al., 2022).

Tensor-network-assisted AQC broadens the target class from gates to many-body states. AQCtensor introduces a global-optimization approach for producing short-depth circuits from MPS, tailored to time-evolved quantum many-body states, and claims constant depth in the number of qubits for fixed simulation time and fixed error tolerance; on 100-qubit simulation problems it reports at least an order-of-magnitude reduction in circuit depth relative to generic MPS-to-circuit methods (Robertson et al., 2023). “Variational preparation of normal matrix product states on quantum computers” develops ADAPT-AQC and a generalized initialization for AQC-Tensor. For a 50-site XXZ ground state with bond dimension $U_{\rm optim}$5, it reports fidelity $U_{\rm optim}$6 with CNOT depth 28 for ADAPT-AQC and CNOT depth 18 for AQC-Tensor, compared with depth 157 for the best truncated staircase method and 46,157 for the exact Schön circuit (Jaderberg et al., 12 Mar 2025).

Barren plateaus form the main methodological controversy in variational AQC. “Escaping barren plateaus in approximate quantum compiling” shows that global cost functions can produce exponentially vanishing gradient variance, while localized costs based on explicit bit-flip expansions can improve trainability for both state preparation and unitary compilation (Robertson et al., 2022). This does not refute barren plateaus as a phenomenon; rather, it relocates the practical question to cost-function design and ansatz locality.

5. Hardware alignment and application domains

AQC is strongly hardware-conditioned. In fault-tolerant single-qubit compiling, the gate set is essentially Clifford+$U_{\rm optim}$7 on the Steane code, and minimizing $U_{\rm optim}$8-count is central because $U_{\rm optim}$9 gates are costly (Jr, 2012). In topological compiling, the primitives are braid generators $T$0 of Fibonacci anyons, and braid length directly measures physical exchange cost (Long et al., 3 Jan 2025). In superconducting control, the self-navigation method is built around a drift Hamiltonian $T$1, a driven $T$2-plane control Hamiltonian, and the availability of virtual $T$3 gates (He et al., 2022).

At the NISQ circuit level, approximate compiling is used as a depth-compression mechanism. “Efficient Quantum Circuit Compilation for Near-Term Quantum Advantage” compiles Ising time evolution, QFT, and Haar-random circuits into brick-wall CNOT layouts, defines $T$4, and reports a compression rate of $T$5 for $T$6 on IBM hardware; in numerical simulations up to $T$7, the optimal depth $T$8 for maximal overall fidelity is reported to be independent of $T$9 (Guo et al., 13 Jan 2025). The same paper also argues that compressibility is correlated with the rate of entanglement accumulation: critical Ising dynamics and QFT are compressible, whereas Haar-random circuits are much less so (Guo et al., 13 Jan 2025).

Application-specific subroutine compression appears in HHL-based and amplitude-estimation-based workflows. In the quantum multi-output Gaussian-process paper, AQC is applied to the QPE subroutine inside HHL, reducing circuit depth from “order of billions” to “order of few hundreds” and enabling a 13-qubit HHL circuit for a $$\mathrm{dist}(U,U_l)=\sqrt{\frac{2-\left|\mathrm{tr}(UU_l^\dagger)\right|}{2}},$$0 kernel matrix inversion on IBM Auckland (Ganeshamurthy et al., 2024). In energy risk analysis, piecewise AQC segments wide circuits into blocks on at most $$\mathrm{dist}(U,U_l)=\sqrt{\frac{2-\left|\mathrm{tr}(UU_l^\dagger)\right|}{2}},$$1 qubits, applies AQC locally, and reinserts the approximate blocks. That work combines pAQC with Dynamic Amplitude Estimation, error mitigation, and IBM hardware experiments to compute expectation, VaR, and CVaR for energy portfolios (Ghosh et al., 2023).

6. Limitations, misconceptions, and open directions

The most persistent limitation is that better constants rarely remove the underlying hardness. Fowler’s compiler remains exponential in sequence length even after the meet-in-the-middle and basis-change optimizations (Jr, 2012). Best-approximate and sketching formulations still face nonconvex landscapes and barren plateaus, even if sketching extends the reachable system size (Madden et al., 2021, Madden et al., 2022). The HHL/QPE application explicitly notes that AQC can fail to converge for high-dimensional $$\mathrm{dist}(U,U_l)=\sqrt{\frac{2-\left|\mathrm{tr}(UU_l^\dagger)\right|}{2}},$$2 because of barren plateau phenomena (Ganeshamurthy et al., 2024).

A second misconception is that approximate always means heuristic and uncontrolled. Several papers formulate explicit optimization problems with transparent error objectives: Frobenius-norm minimization over hardware-constrained circuit families (Madden et al., 2021), global program optimization under a specified error budget (Meuli et al., 2020), or fidelity-based MPS compilation with a stopping tolerance (Jaderberg et al., 12 Mar 2025). What varies is not whether the approximation is specified, but which resource is held fixed: sequence length, CNOT depth, ansatz structure, or total program error.

A third recurring issue is task dependence. Some methods are highly specialized. Number-theoretic or braid-based approaches target special gate sets (Long et al., 3 Jan 2025). Self-navigation is a single-qubit control method for weakly anharmonic hardware (He et al., 2022). AQCtensor and ADAPT-AQC rely on short-range-correlated normal MPS and 1D tensor-network efficiency (Robertson et al., 2023, Jaderberg et al., 12 Mar 2025). Brick-wall compression works well for Ising dynamics and QFT but not for Haar-random circuits (Guo et al., 13 Jan 2025). This suggests that there is no basis-independent notion of “best” AQC outside a specified hardware and workload model.

Open directions in the cited literature are correspondingly diverse. They include multidimensional indexing and parallelism for exhaustive single-qubit synthesis (Jr, 2012), systematic mitigation of barren plateaus in classically assisted compiling (Robertson et al., 2022), adaptive ansätze and better initialization for tensor-network state preparation (Jaderberg et al., 12 Mar 2025), application-level error models for approximate HHL and kernel inversion (Ganeshamurthy et al., 2024), and compiler frameworks that jointly optimize synthesis precision, Trotter error, approximate QFT, and phase-estimation accuracy through symbolic resource estimation (Meuli et al., 2020). A plausible implication is that future AQC systems will remain heterogeneous: discrete search, variational optimization, tensor-network compression, and compiler-level error budgeting are likely to coexist rather than collapse into a single universal methodology.