ReOC: Compilation of Recursive Quantum Oracles with Recursion-Aware Uncomputation

2026-08-08

AI Summary

This work addresses the challenge that existing reversible compilation frameworks struggle to effectively support recursive quantum oracles whose control flow depends on runtime quantum data. To overcome this limitation, the paper proposes ReOC, a novel compilation framework that first introduces RQIMP, a high-level language for specifying recursive quantum oracles, and compiles it into RQC++, a target language supporting quantum-controlled flow. The framework incorporates an indexed static register mechanism to isolate variables across recursion levels and employs a hybrid deferred-and-eager uncomputation strategy aware of recursion structure. Under strict guarantees of reversibility and semantic correctness, this approach reduces both time and space overheads of linear recursion to scale linearly with recursion depth, significantly outperforming current state-of-the-art solutions.

Abstract

Quantum oracles are essential to many quantum algorithms, and their specifications may involve recursive control flow that depends on runtime quantum data. However, existing reversible compilation frameworks provide limited support for such quantum-controlled recursive structures. We present ReOC, a compilation framework that transforms high-level recursive oracle specifications with quantum control flow into reversible quantum programs. The framework comprises RQIMP, a high-level imperative source language for specifying recursive oracles, and a method of compiling programs in that language into RQC++, an existing high-level quantum recursive language with quantum control flow. In this way, we avoid the tedious and error-prone process of directly writing quantum oracles in RQC++. To manage static storage under dynamic quantum control, ReOC uses an indexed static-register discipline to isolate live variables across recursion layers, enabling safe register reuse while controlling quantum storage usage. Furthermore, to address the exponential time blow-up caused by naive uncomputation in recursive settings, ReOC employs a recursion-aware uncomputation strategy: temporary variables from recursive calls are cleaned using deferred strategies to control time overhead, while those from non-recursive statements are cleaned eagerly to reduce space usage. For linear recursion, this strategy yields overhead linear in recursion depth, parameterized by the per-layer register footprint and primitive-operation costs. Finally, we provide a mathematical proof of compilation correctness from RQIMP to RQC++, establishing semantic preservation and correct uncomputation of temporary quantum variables.

Problem

• quantum oracles
• recursive control flow
• reversible compilation
• quantum computation
• uncomputation

Innovation

• recursive quantum oracles
• recursion-aware uncomputation
• quantum compilation
• static-register discipline
• quantum control flow