Universal Programmable Quantum Circuit Schemes to Emulate an Operator

Anmer Daskin, Ananth Grama, Giorgios Kollias, Sabre KaisarXiv 2012 · arXiv

Abstract

In current quantum computing paradigms, executing a specific algorithm typically requires custom circuit designs tailored to a particular unitary operator, often involving computationally expensive classical matrix decomposition. This paper introduces two novel universal, programmable quantum circuit architectures that can emulate any $N \times N$ matrix operator—including non-unitary ones—by simply adjusting the angles of rotation gates. By leveraging auxiliary (ancilla) qubits and a fixed-design layout, these schemes reduce classical preprocessing complexity to $O(N \log N)$, paving the way for FPGA-like programmable quantum processors.

Introduction: The Challenge of Fixed Logic

Classical computing benefits from programmable logic devices like FPGAs, which can be reconfigured post-manufacturing to perform diverse hardware-level functions. In contrast, quantum computing has historically relied on "fixed logic" circuits. To run a specific simulation or algorithm, engineers must custom-design a circuit layout using classical techniques like QR or Shannon decomposition. These methods are not only computationally intensive but also result in hardware that is specialized for a single task.

The authors address this by proposing a general-purpose, programmable quantum circuit architecture. Their goal is a single, fixed physical layout of gates that can simulate any operator solely by tweaking gate parameters (rotation angles), eliminating the need for rewiring or global optimization algorithms.

Methodology: A Three-Step Universal Emulation

The proposed architectures utilize $n$ main qubits and a set of auxiliary (ancilla) qubits to embed a target $N \times N$ matrix into a larger, higher-dimensional unitary matrix. This process follows a modular three-step workflow.

High-level block diagram of the three-step emulation process: Input Modification, Formation, and Combination.
  1. Input Modification: This stage prepares the initial quantum state using Hadamard and SWAP gates. This ensures that the final measurement correctly isolates the states corresponding to the simulated operator.
  2. Formation Step: This step encodes the target matrix elements. In Scheme 1, individual elements are encoded directly onto the diagonal of a larger matrix using uniformly controlled rotation gates. Scheme 2 builds small blocks (e.g., 2x2 or 4x4) that preserve the mathematical ratios of the target matrix elements.
  3. Combination Step: Controlled operations are used to recursively merge these elements or blocks until the full target matrix rows are constructed.
Detailed circuit architecture for Scheme 1, illustrating the use of ancilla qubits, Hadamard gates for state preparation, and controlled rotation gates to emulate an operator.

Key Insights and Performance

Efficient Classical Preprocessing

Because gate angles are derived directly from matrix elements using simple arccosine functions, the classical overhead is minimal. Utilizing the Fast Hadamard Transform, the "programming" time is $O(N \log N)$, avoiding the massive overhead of traditional decomposition methods.

Native Support for Non-Unitary Matrices

By utilizing the extra Hilbert space provided by ancilla qubits, the circuit can natively simulate non-unitary matrices. This is a significant advantage, as non-unitary operations are notoriously difficult to implement in standard quantum circuits.

Exploiting Sparsity

If the target matrix is sparse, the circuit design can be drastically simplified. Zero elements translate to identity gates, reducing the required number of ancilla qubits and combination steps. For example, in a hydrogen molecule simulation, the authors reduced the required ancilla qubits from 5 to 2 by exploiting the matrix's 19 non-zero elements.

Complexity Trade-offs

The CNOT gate complexity for these circuits is approximately $O(2^{2n})$. While this is roughly double the complexity of the most efficient non-programmable custom circuits, it represents a highly acceptable trade-off for universal programmability. Furthermore, by optimizing block sizes in Scheme 2, it is theoretically possible to push complexity below the proven lower bounds for standard no-ancilla decompositions.

Conclusion and Future Outlook

This architecture serves as a blueprint for "Quantum FPGAs"—chips fabricated once and programmed via a preprocessing unit. Future work includes parallelizing the angle-finding process and developing application-specific chips optimized for the sparsity patterns found in quantum chemistry or molecular simulations. This approach moves quantum hardware closer to the flexibility and reconfigurability of modern classical processors.

Summary updated

BibTeX
@misc{daskin2012universal,
  author = {Anmer Daskin and Ananth Grama and Giorgios Kollias and Sabre Kais},
  title = {{Universal Programmable Quantum Circuit Schemes to Emulate an Operator}},
  year = {2012},
  eprint = {1204.3600},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/1204.3600},
}
Figure