DC: Depth Control on Quantum Classical Circuit

Movahhed Sadeghi, Soheil Khadirsharbiyani, Mostafa Eghbali Zarch, Mahmut KandemirarXiv 2023 · DOI · arXiv

TL;DR

This paper introduces Depth Control (DC), a technique that allows "infinitely large" quantum classical circuits to run reliably on noisy (NISQ) hardware. By slicing deep circuits into smaller blocks and using classical memory to "reset" qubit states between them, the authors achieved an average 11x improvement in success probability compared to standard execution methods.

What Problem Does This Paper Address?

We are currently in the Noisy Intermediate-Scale Quantum (NISQ) era. While quantum computers exist, they are incredibly "loud." Errors from gate operations, qubit decoherence, and crosstalk accumulate rapidly. As a quantum circuit grows in depth (more sequential operations), the signal-to-noise ratio plummets until the final output is indistinguishable from random noise.

Existing solutions like Quantum Error Correction (QEC) require a massive overhead of physical qubits that we simply don't have yet. This paper focuses specifically on Quantum Classical Circuits (QCCs)—classical logic (like AND, NAND, and XOR) implemented using quantum gates. These are vital for backward compatibility and as sub-routines in larger algorithms (like Shor’s). The "wall" for these circuits is reliability; once they reach a certain depth, they become unusable on real hardware.

Methods

The authors propose a "divide and conquer" strategy called Depth Control (DC). The core idea is to treat classical memory as a temporary "save point" for quantum states.

  1. Slicing: A large circuit is broken into smaller "blocks."
  2. Measurement & Correction: At the end of each block, the qubits are measured. Because these are classical circuits, the state should be a clean $|0\rangle$ or $|1\rangle$. Measurement collapses the noisy, error-prone state back into a definite classical value, effectively "filtering" the accumulated noise.
  3. Initialization: This classical value is then used to initialize the qubits for the next block (using $X$ gates where necessary).

The authors developed two implementation strategies:

  • Static Depth Control (SDC): Slices the circuit into blocks of a fixed size (e.g., every 5 gates). This is simple and reduces the algorithmic complexity of mapping/routing from exponential to linear ($O(n)$).
  • Dynamic Depth Control (DDC): A more sophisticated approach that uses simulation to estimate the "fidelity" of a block. If the predicted reliability is too low, it halves the block size until it hits a safe threshold.

Crucially, they also proposed a method to handle superposition inputs by distributing "shots" across multiple deterministic paths, and a "reverse DC" algorithm to maintain reversibility, a key feature of quantum logic.

Datasets

The researchers evaluated their method using standard benchmarks from the QASM benchmark suite and Revlib. Specifically, they tested:

  • Arithmetic and logic units (e.g., alu-v2_30, Multiplier-n-25)
  • Standard logic benchmarks (e.g., C17_204, cm82a_208, ex2_227)
  • Quantum Fourier Transform sub-components (qft_16)

All experiments were run on the ibm_cairo machine, a 27-qubit Falcon r5.11 processor.

Key Insights and Ideas

  • Classical Memory as a Proxy: Since we don't have reliable "quantum memory" yet, the authors realized that for classical logic, we can use standard classical bits to bridge the gap between quantum operations. It’s analogous to DRAM refresh cycles—preventing data loss before it becomes fatal.
  • Complexity Hack: Qubit mapping and routing (deciding which physical qubit handles which logical operation) is an NP-complete problem. By forcing the circuit into tiny, constant-sized blocks, the authors effectively bypassed this complexity, making optimization much faster for massive circuits.
  • The Simulation Gap: A surprising finding was that SDC often outperformed DDC. Why? Because current quantum simulators don't perfectly model hardware noise like crosstalk. DDC relied on these simulations to pick block sizes, while the "dumb" static approach was more robust to real-world hardware quirks.

Key Results

  • 11x PST Boost: The Probability of Success Threshold (PST)—the likelihood of getting the right answer—improved by an average of 11x over non-DC baselines.
  • Reliability Margin: DC didn't just make the right answer more likely; it created a "substantial gap" between the correct output and the next most frequent (wrong) result, making the data actually verifiable.
  • Infinite Depth: Theoretically, as long as a single block is small enough to run reliably, DC allows for a circuit of any depth to be executed by chaining these blocks together.
  • Speedup: The mapping/routing process saw a transition from $O(m!n!)$ complexity down to $O(n)$, a massive win for compiler efficiency.

Limitations and Future Work

  • The "Classical" Constraint: The biggest limitation is that this specific measurement-and-reset technique only works for classical logic. It cannot be directly applied to general quantum algorithms (like those involving deep entanglement or complex phases) because mid-circuit measurement would collapse the quantum state and destroy the "quantumness."
  • Queue Latency: Slicing a circuit into 50 blocks means sending 50 separate "jobs" to the quantum provider. In a cloud environment with long wait times, this could make the total execution time significantly longer.
  • Future Directions: The authors aim to generalize this "noise filtering" approach. As quantum memory technology matures, they hope to adapt DC to handle non-classical quantum states, potentially providing a bridge to full-scale fault-tolerant quantum computing.

Summary updated

Abstract

The growing prevalence of near-term intermediate-scale quantum (NISQ) systems has brought forth a heightened focus on the issue of circuit reliability. Several quantum computing activities, such as circuit design and multi-qubit mapping, are focused on enhancing reliability via the use of different optimization techniques. The optimization of quantum classical circuits has been the subject of substantial research, with a focus on techniques such as ancilla-qubit reuse and tactics aimed at minimizing circuit size and depth. Nevertheless, the reliability of bigger and more complex circuits remains a difficulty due to potential failures or the need for time-consuming compilation processes, despite the use of modern optimization strategies. This study presents a revolutionary Depth Control (DC) methodology that involves slicing and lowering the depth of conventional circuits. This strategy aims to improve the reliability and decrease the mapping costs associated with quantum hardware. DC provides reliable outcomes for circuits of indefinite size on any Noisy Intermediate-Scale Quantum (NISQ) system. The experimental findings demonstrate that the use of DC leads to a substantial improvement in the Probability of Success Threshold (PST), with an average increase of 11x compared to non-DC baselines. Furthermore, DC exhibits a notable superiority over the next best outcome by ensuring accurate outputs with a considerable margin. In addition, the utilization of Design Compiler (DC) enables the execution of mapping and routing optimizations inside a polynomial-time complexity, which represents an advancement compared to previously suggested methods that need exponential time.
BibTeX
@misc{sadeghi2023dc,
  author = {Movahhed Sadeghi and Soheil Khadirsharbiyani and Mostafa Eghbali Zarch and Mahmut Kandemir},
  title = {{DC: Depth Control on Quantum Classical Circuit}},
  year = {2023},
  eprint = {2305.11919},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2305.11919},
}
Figure