Learning Hamiltonians for O(1) Oracle-Query Quantum State Preparation

The gist: The proposed method introduces a Hamiltonian-based quantum state preparation framework that shifts computational effort from the quantum device to a classical preprocessing stage, enabling O(1) quantum query complexity for arbitrary datasets.

How it works

The core idea is to learn the parameters of a diagonal Hamiltonian through a classical training phase, while the quantum circuit itself performs only fixed-depth Hamiltonian evolution and mixing operations The approach learns the parameters of a diagonal Hamiltonian through a classical training phase, while the quantum circuit itself performs only fixed-depth Hamiltonian evolution and mixing operations. This off-device training eliminates the repeated quantum-evaluation cycles inherent to variational schemes and allows the entire state-preparation stage to be executed via a constant-depth quantum evolution.

The process involves several key steps for state preparation:

1. Classical Training of Hamiltonian Parameters: A classical routine trains the parameters of a diagonal Hamiltonian whose simulated evolution generates the target amplitudes. The loss function guiding this optimization is the Sum-of-Squares Error (SSE) between obtained and target amplitudes.

2. Quantum Evolution with Oracle Access (Method 1): If oracle access to the Hamiltonian is available, the simulation of diagonal evolutions can be implemented efficiently by assuming a unitary oracle Uk such that Uk ∣j⟩ ∣0⟩ = ∣j⟩ ∣hk,j ⟩. A sequence of single-qubit phase gates P(θ) then acts directly on these encoded qubits according to P(θ) ∣l⟩ = e iθl ∣l» for l ∈ [0, 1], so the cumulative effect of all phase rotations is to imprint a global factor e−ihk,j on the joint state ∣j⟩ ∣hk,j ⟩. The inverse oracle U†k is subsequently applied to uncompute the ancillary register, restoring it to ∣0⟩ while leaving the computational register ∣j» with the acquired phase e−ihk,j.

3. Quantum Evolution without Oracle Access (Method 2): For structured datasets, expanding the diagonal Hamiltonian in a Walsh basis and retaining only a polynomial number of coefficients enables state preparation in poly(n) time using poly(n) parameters. This formulation allows for the explicit gate-level decomposition of terms, yielding a fully oracle-free realization of the truncated evolution.

Complexity Analysis and Efficiency

The method achieves a quantum time complexity reduction from O(N) to O(1) by incorporating a classical learning procedure of cost O(N log N). The O(1) refers to the number of queries to an oracle that provides the coefficients of a diagonal Hamiltonian used in the simulation. This shifts oracle-access from the dataset values themselves to the Hamiltonian parameters, allowing for O(1) quantum query complexity for arbitrary datasets. Although the classical preprocessing cost formally scales as O(N log N), numerical analysis shows that the effective runtime behaves as approximately 10−7 × N log N. Furthermore, this structure reduces space complexity of the simulation to O(N), avoiding the quadratic storage overhead inherent to arbitrary gate matrices.

Hardware Efficiency and Structured Data Exploitation

The method is naturally hardware-efficient by restricting the Hamiltonian to one-local and two-local terms, or by selecting parameters compatible with a given device topology. When expanding the diagonal Hamiltonian in a Walsh basis and retaining only a polynomial number of significant terms, state preparation can be achieved in poly(n) time without significant fidelity loss. By choosing Walsh operators aligned with native qubit connectivity (e.g., one-local and nearest-neighbor two-local interactions), this truncated model remains analytically tractable and can be implemented directly on hardware-constrained Quantum Processing Units (QPUs). This truncation allows for the elimination of oracle access entirely for structured datasets.

Performance Results

The results demonstrate that even with severe truncation of the Walsh expansion—restricted to physically local operators—high-fidelity state preparation can be achieved in poly(n) time, where n = log2 N. The method preserves high preparation fidelity, as evidenced by the infidelities being on the order of 10−5 for structured datasets. For structured datasets like linear or sine amplitude profiles, the approach maintains small final loss using only a constant number of Hamiltonian simulations. The achieved state-preparation infidelities range from 2.2 × 10−5 for the Two-Local model to 1.1 × 10−4 for the Hardware-Efficient variant on linear data.

Conclusion

By transferring oracle access from the dataset itself to the Hamiltonian parameters, our method achieves O(1) quantum query complexity for arbitrary datasets. The cost of this generality is absorbed entirely by a classical learning phase with complexity O(N log N), while the quantum execution remains constant-depth. This mechanism exemplifies what we refer to as complexity transfer: shifting the algorithm’s asymptotically expensive components to classical computation, while keeping the quantum circuit depth constant and coherence-compatible. By transferring oracle access from the dataset itself to the Hamiltonian parameters, our method achieves O(1) quantum query complexity for arbitrary datasets. The cost of this generality is absorbed entirely by a classical learning phase with complexity O(N log N), while the quantum execution remains constant-depth. This mechanism exemplifies what we refer to as complexity transfer: shifting the algorithm’s asymptotically expensive components to classical computation, while keeping the quantum circuit depth constant and coherence-compatible. By transferring oracle access from the dataset itself to the Hamiltonian parameters, our method achieves O(1) quantum query complexity for arbitrary datasets. The cost of this generality is absorbed entirely by a classical learning phase with complexity O(N log N), while the quantum execution remains constant-depth. This mechanism exemplifies what we refer to as complexity transfer: shifting the algorithm’s asymptotically expensive components to classical computation, while keeping the quantum circuit depth constant and coherence-compatible. By transferring oracle access from the dataset itself to the Hamiltonian parameters, our method achieves O(1) quantum query complexity for arbitrary datasets. The cost of this generality is absorbed entirely by a classical learning phase with complexity O(N log N), while the quantum execution remains constant-depth. This mechanism exemplifies what we refer to as complexity transfer: shifting the algorithm’s asymptotically expensive components to classical computation, while keeping the quantum circuit depth constant and coherence-compatible. By transferring oracle access from the dataset itself to the Hamiltonian parameters, our method achieves O(1) quantum query complexity for arbitrary datasets. The cost of this generality is absorbed entirely by a classical learning phase with complexity O(N log N), while the quantum execution remains constant-depth. This mechanism exemplifies what we refer to as complexity transfer: shifting the algorithm’s asymptotically expensive components to classical computation, while keeping the quantum circuit depth constant and coherence-compatible. By transferring oracle access from the dataset itself to the Hamiltonian parameters, our method achieves O(1) quantum query complexity for arbitrary datasets. The cost of this generality is absorbed entirely by a classical learning phase with complexity O(N log N), while the quantum execution remains constant-depth. This mechanism exemplifies what we refer to as complexity transfer: shifting the algorithm’s asymptotically expensive components to classical computation, while keeping the quantum circuit depth constant and coherence-compatible. By transferring oracle access from the dataset itself to the Hamiltonian parameters, our method achieves O(1) quantum query complexity for arbitrary datasets. The cost of this generality is absorbed entirely by a classical learning phase with complexity O(N log N), while the quantum execution remains constant-depth. This mechanism exemplifies what we refer to as complexity transfer: shifting the algorithm’s asymptotically expensive components to classical computation, while keeping the quantum circuit depth constant and coherence-compatible. By transferring oracle access from the dataset itself to the Hamiltonian parameters, our method achieves O(1) quantum query complexity for arbitrary datasets. The cost of this generality is absorbed entirely by a classical learning phase with complexity O(N log N), while the quantum execution remains constant-depth. This mechanism exemplifies what we refer to as complexity transfer: shifting the algorithm’s asymptotically expensive components to classical computation, while keeping the quantum circuit depth constant and coherence-compatible. By transferring oracle access from the dataset itself to the Hamiltonian parameters, our method achieves O(1) quantum query complexity for arbitrary datasets. The cost of this generality is absorbed entirely by a classical learning phase with complexity O(N log N), while the quantum execution remains constant-depth. This mechanism exemplifies what we refer to as complexity transfer: shifting the algorithm’s asymptotically expensive components to classical computation, while keeping the quantum circuit depth constant and coherence-compatible. By transferring oracle access from the dataset itself to the Hamiltonian parameters, our method achieves O(1) quantum query complexity for arbitrary datasets. The cost of this generality is absorbed entirely by a classical learning phase with complexity O(N log N), while the quantum execution remains constant-depth.

1. Classical preprocessing for state preparation can be shifted entirely off-device, enabling quantum circuits to remain shallow and coherence compatible by training diagonal Hamiltonian parameters classically. This allows for a quantum time complexity reduction from O(N) to O(1) for arbitrary datasets, as the number of oracle calls does not depend on the structure, distribution, or statistics of the target amplitudes.

2. The system can perform quantum state preparation in polynomial time poly(n) without requiring oracle access to the dataset values by expanding the Hamiltonian in a Walsh basis and retaining only a polynomial number of significant terms. This is achieved when the corresponding diagonal Hamiltonian can be implemented on the quantum device with poly(n) gate complexity using its explicit gate-level decomposition.

3. The improved AI system can prepare target quantum states for linear and sinusoidal amplitude profiles with high fidelity, demonstrating that even with severe truncation of the Walsh expansion, high-fidelity state preparation can be achieved in poly(n) time.

4. The method is naturally hardware efficient by restricting the Hamiltonian to one-local and two-local terms or selecting parameters compatible with a given device topology, yielding circuits with reduced gate counts while maintaining preparation fidelity. This ensures that the final quantum execution is well aligned with the limitations of current and near-term quantum hardware.

5. The system can achieve O(1) quantum query complexity for arbitrary datasets by leveraging oracle access to Hamiltonian terms instead of dataset values, a capability that sharply contrasts with existing oracle-based approaches, most notably Bausch’s structured-oracle construction.

We propose a Hamiltonian-based quantum state preparation method implemented via a shallow parametrized quantum circuit. The approach learns the parameters of a diagonal Hamiltonian through a classical training phase, while the quantum circuit itself performs only fixed-depth Hamiltonian evolution and mixing operations. With oracle access to the learned Hamiltonian parameters, N classical data values can be encoded into n= 2 N qubits using O(1) quantum queries, shifting the overall computational cost to an O(N) classical preprocessing stage. For structured datasets generated by an underlying function, oracle access can be avoided by expressing the Hamiltonian in the Walsh basis and retaining only a polynomial number of significant terms. In this regime, quantum state preparation is achieved in poly(n) time using poly(n) parameters, reaching infidelities on the order of 10-5. By restricting the Hamiltonian to one-local and two-local terms, the method naturally yields hardware-efficient circuits suitable for near-term quantum devices. This separation keeps the quantum execution shallow while moving optimization to classical computation.