PaperlayerView exact revision on arXiv

Source-linked AI summary

Variational Quantum State Diagonalization

Ryan LaRose, Arkin Tikku, Étude O'Neel-Judy, Lukasz Cincio, Patrick J. Coles

arXiv:1810.10506v2quant-ph

TL;DR

Quantum state diagonalization is useful for entanglement spectroscopy and principal component analysis, but existing qPCA subroutines require substantial quantum resources for near-term implementation. This paper introduces VQSD, a variational hybrid algorithm that trains a parameterized unitary toward diagonality, then reads out dominant eigenvalues and prepares associated eigenvectors. Proof-of-principle implementations diagonalize one-qubit states and obtain dominant Heisenberg-model spectra, while the method is intended for low-rank or low-entropy states.

  • Problem

    Quantum-state diagonalization has applications in entanglement spectroscopy and principal component analysis, while qPCA’s required qubits and gates make it difficult to implement near term.

  • Method

    VQSD variationally trains a layered parameterized unitary to approximately diagonalize ρ, then measures the eigenbasis and prepares eigenvectors associated with the largest inferred eigenvalues.

  • Results

    VQSD successfully diagonalized one-qubit pure states on Rigetti’s quantum computer and accurately obtained the dominant spectrum and associated quantum numbers of Heisenberg-model reduced states in simulation.

  • Takeaways & Limitations

    The algorithm provides approximate largest-eigenvalue and eigenvector estimates using a variational hybrid procedure with a hierarchy controlled by ansatz depth.

  • Takeaways & Limitations

    VQSD is intended for low-rank or low-entropy states because eigenvalue readout becomes exponentially complex for high-entropy states.

Abstract

from arXiv · show

Variational hybrid quantum-classical algorithms are promising candidates for near-term implementation on quantum computers. In these algorithms, a quantum computer evaluates the cost of a gate sequence (with speedup over classical cost evaluation), and a classical computer uses this information to adjust the parameters of the gate sequence. Here we present such an algorithm for quantum state diagonalization. State diagonalization has applications in condensed matter physics (e.g., entanglement spectroscopy) as well as in machine learning (e.g., principal component analysis). For a quantum state $ρ$ and gate sequence $U$, our cost function quantifies how far $ UρU^{\dagger}$ is from being diagonal. We introduce novel short-depth quantum circuits to quantify our cost. Minimizing this cost returns a gate sequence that approximately diagonalizes $ρ$. One can then read out approximations of the largest eigenvalues, and the associated eigenvectors, of $ρ$. As a proof-of-principle, we implement our algorithm on Rigetti's quantum computer to diagonalize one-qubit states and on a simulator to find the entanglement spectrum of the Heisenberg model ground state.

I. INTRODUCTION

VQSD applies a variational hybrid approach to approximate quantum-state diagonalization, motivated by applications in entanglement spectroscopy and principal component analysis. Its layered unitary, cost function, and iterative structure trade solution quality against resources while targeting the largest eigenvalues and associated eigenvectors.

  • Motivation: Diagonalizing quantum states supports entanglement spectroscopy in condensed matter physics and principal component analysis in machine learning.PCA uses covariance-matrix diagonalization to identify high-variance features and reduce dimensionality.
  • Motivation: qPCA can offer exponential speedup for low-rank matrices, but its phase-estimation and density-matrix-exponentiation subroutines require substantial qubits and gates.These requirements make qPCA difficult to implement near term.
  • VQSD proposal: VQSD trains a parameterized unitary so the transformed state is approximately diagonal, then reads out the largest eigenvalues and prepares their associated eigenvectors.The algorithm uses three stages: parameter training, eigenvalue readout, and eigenvector preparation.
  • VQSD proposal: A layered ansatz with p layers provides a hierarchy of approximate eigensystem solutions, allowing users to trade runtime and accuracy through iterative optimization.The number of layers acts as a hyperparameter controlling the approximation quality.
  • Cost and guarantees: The cost function is designed to vanish exactly for diagonal transformed states, be quantum-computable, bound eigensystem errors, and avoid exponentially vanishing training gradients.Its construction uses differences of purities and novel short-depth circuits.
  • Implementation: Proof-of-principle experiments diagonalized one-qubit pure states on Rigetti’s 8-qubit computer and studied a 12-spin Heisenberg ground state on a simulator.The simulator implementation targeted entanglement spectroscopy.

2. Parameter Optimization Loop

The parameter-optimization loop minimizes a purity-based cost that measures departure from diagonality using short-depth quantum circuits and classical parameter updates. Two component costs share the same diagonalizing minima, while their complementary landscapes support operational accuracy and trainability.

  • Ansatz: A layered two-body-gate ansatz keeps parameter growth at most polynomial in n and p while supporting parallel gate execution.The ansatz may also be modified during optimization through an alternative construction.
  • Optimization loop: VQSD iteratively evaluates the cost on a quantum computer and updates unitary parameters on a classical computer.The classical optimizer may use gradient-free or gradient-based methods.
  • Cost functions: C1 and C2 vanish under exactly the same condition: the transformed state is diagonal, so their global minima correspond to diagonalizing unitaries.This shared minimum allows the two costs to be combined without changing the target solutions.
  • Cost functions: C1 bounds eigenvalue error and equals the defined eigenvector error, whereas C2 is more sensitive to unitary changes and is useful for training at large n.C2 lacks the same direct operational meaning but satisfies C2 >= (1/n)C1.
  • Combined cost: The overall cost is a weighted average of C1 and C2, with q allowing the balance to be tailored to problem scale.The paper recommends q approximately 1 for small n and small q for large n.
  • Cost evaluation: The cost is expressed through purities, whose evaluation uses quantum circuits with depth constant in the number of qubits and classical post-processing linear in that number.The circuit for one purity term has depth one gate, while the state-independent purity is evaluated outside the loop.

3. Eigenvalue Readout

After optimization, VQSD estimates eigenvalues by measuring the transformed state in the standard basis and uses selected measurement bitstrings to prepare corresponding eigenvectors. Readout precision favors larger eigenvalues and depends on sampling and the chosen error threshold.

  • Readout procedure: The readout circuit applies the optimized unitary to one copy of ρ and measures in the standard basis to obtain probabilities treated as inferred eigenvalues.These probabilities are the diagonal elements of the transformed state, not necessarily its exact eigenvalues.
  • Readout procedure: Each measurement produces a bitstring z, whose frequency over Nreadout runs estimates the corresponding inferred eigenvalue.The statistical deviation scales as 1/√Nreadout.
  • Precision: Higher-frequency bitstrings have lower relative error, so larger inferred eigenvalues are characterized more precisely.This makes the procedure naturally suited to estimating the dominant spectrum.
  • Precision: The number m of precisely characterized eigenvalues is determined by Nreadout, the relative-error threshold ϵmax, and the inferred eigenvalues.The selected eigenvalues are those estimated with the desired precision.
  • Eigenvector preparation: For each selected bitstring, VQSD prepares the associated inferred eigenvector by applying X gates to create the computational-basis state and then applying the optimized unitary’s inverse.The prepared eigenvectors remain quantum states and can be probed through expectation values of observables.

B. Implementations

VQSD was demonstrated on Rigetti’s quantum computer for a one-qubit pure state and on a simulator for a Heisenberg-model reduced state. The implementations recovered the expected eigenvalues, eigenvalue degeneracies, and associated quantum numbers, while current hardware limits problem size.

  • One-Qubit State: After four iterations, the inferred eigenvalues approached {0, 1}, as required for the pure input state.The cost decreased to a small value near zero during optimization.
  • One-Qubit State: On Rigetti’s 8Q-Agave processor, VQSD diagonalized ρ = |+⟩⟨+| using an arbitrary single-qubit rotation ansatz.The implementation used p = 1 and q = 1.
  • One-Qubit State: Hardware cost minima occurred near α = π/2 and 3π/2, although decoherence, gate infidelity, and measurement error kept the cost nonzero.After retuning, the hardware landscape matched the noisy simulator more closely.
  • Heisenberg Model Ground State: For the Heisenberg ground state, a simulator diagonalized the reduced state of four neighboring spins from an eight-spin chain.The complementary four spins formed subsystem B for the reduced state ρ = Tr_B(|ψ⟩⟨ψ|_AB).
  • Heisenberg Model Ground State: As ansatz depth increased, the largest inferred eigenvalues converged to theoretical values with correct degeneracies, and inferred quantum numbers roughly agreed with theory.The implementation used multiple layers up to p = 5 and recovered the largest eigenvalues and their z-component total-spin quantum numbers.
  • Scope and Limitations: VQSD is intended for low-rank or low-entropy states, because eigenvalue readout becomes exponentially complex for high-entropy states.Current hardware noise also restricts implementations to small problem sizes, whereas larger examples were explored on simulators.

A. Comparison to Literature

VQSD addresses quantum-state diagonalization through hybrid optimization and short-depth purity-measurement circuits. Its scope includes entanglement spectroscopy, PCA, state preparation, and noise-process characterization, while comparisons with qPCA and classical PCA remain open.

  • Comparison to Literature: VQSD avoids the exponential memory and matrix-operation costs of storing and classically diagonalizing a density matrix.The paper presents it as a quantum approach to extracting eigenvalues and eigenvectors for suitable states.
  • Comparison to Literature: Like qPCA, VQSD may achieve exponential speedup for particular low-entropy states, but the paper leaves comparative performance questions open.The stated speedup for both methods depends on the input state having low entropy.
  • Future Applications: For pure states, VQSD becomes variational state preparation by learning a unitary that maps the input state to a standard basis state.Inverting that unitary maps a standard basis state to the target state and may yield a short-depth preparation circuit.
  • Future Applications: VQSD can support PCA when QRAM prepares a covariance matrix as a quantum state, potentially enabling dimensionality reduction and noise filtering.The paper notes that classical low-rank PCA methods may achieve similar scaling, motivating future comparisons.
  • Future Applications: VQSD can characterize entanglement spectra after variational quantum eigensolver preparation, supporting studies of condensed-matter phases and topological order.The proposed workflow combines ground-state preparation with subsequent state diagonalization.
  • C1 and the DIP Test: The cost C1 measures distance from diagonality and bounds eigenvalue error while equaling the defined eigenvector error for q = 1.These operational meanings motivate using purity differences to quantify diagonalization quality.
  • C1 and the DIP Test: C1 is evaluated with a Destructive Swap Test for Tr(ρ^2) and a depth-one DIP Test for Tr(Z(ρ̃)^2).The DIP Test avoids the depth-three dephasing-plus-swap alternative and requires no classical postprocessing.

2. C2 and the PDIP Test

C2 uses local dephasing to create a training cost that shares C1’s zero conditions while offering a different computational trade-off. The PDIP Test computes its purity terms through a circuit that interpolates between the swap and DIP tests.

  • C2 and the PDIP Test: C2 is the average Hilbert-Schmidt distance between ρ̃ and its locally dephased states Z_j(ρ̃).Because local dephasing removes fewer coherences than global dephasing, the paper expects C2 ≤ C1.
  • C2 and the PDIP Test: C2 and C1 vanish under precisely the same conditions, and C2 also upper-bounds (1/n)C1.Thus C2 preserves the zero-cost criterion for diagonalization while providing a scaled relation to C1.
  • C2 and the PDIP Test: The PDIP Test computes Tr(Z_j(ρ̃)^2) by combining DIP processing on selected qubits with Destructive Swap processing on the remaining qubits.With l = 0 it reduces to the Destructive Swap Test; with l = n it reduces to the DIP Test.
  • C2 and the PDIP Test: The PDIP construction generalizes both existing tests while retaining depth-two quantum-circuit evaluation for partially dephased inner products.It is defined for a selected index set of locally dephased qubits.

3. C1 versus C2

C1 and C2 share the same global minima, but trade off operational error guarantees against trainability as the system size grows. The paper therefore motivates combining them in the overall cost function.

  • C1’s circuit is shallower and requires fewer measurements and less post-processing than C2’s circuit.
  • For large n, C1 can develop vanishing gradients away from sharp minima, limiting its usefulness for training.
  • C2’s gradient remains independent of n in the illustrative example and is generally less barren for low-rank or low-entropy states.
  • The optimization procedure uses Powell’s derivative-free method, which preliminary analyses found performed best across convergence, initialization sensitivity, and function evaluations.

Appendix A: Details on VQSD Implementations

The appendix details quantum-computer and simulator implementations, an adaptive ansatz, and optimization strategies for VQSD. Hardware demonstrations target one-qubit states, while simulation reaches Heisenberg-model reduced states and benefits from flexible circuit growth.

  • Quantum computer implementation: The Rigetti implementation prepares two plus-state copies, applies a native one-layer ansatz, and uses the circuit divided into logical sections.
  • Quantum computer implementation: Powell optimization found the minimum cost in fewer than ten objective-function evaluations on average, using 10,000 circuit samples per evaluation.
  • Quantum computer implementation: Noise limited quantum-hardware implementations to one-qubit states and could prevent the measured cost from reaching zero despite optimal parameters.
  • Simulator implementation: The simulator handled four-qubit states with up to five ansatz layers and used directly calculated measurement probabilities to enable gradient-based optimization.
  • Alternative ansatz: Allowing the ansatz structure to change during optimization produced fewer-gate diagonalizing circuits and lower eigenvalue error than a fixed layered ansatz for the same gate count.
  • Heisenberg-model application: VQSD accurately obtained the dominant spectrum and associated quantum numbers of a six-qubit reduced state from the 12-qubit Heisenberg-model ground state.
  • Optimization and local minima: The classical optimization can be difficult because a 150-gate example required optimization over at least 150 · 13 continuous parameters and contained multiple local minima.
  • Optimization and local minima: Growing the circuit with identity gates enabled every run to reach a predefined cost of 2 · 10^-6 and helped escape suboptimal local minima.

Appendix D: Optimization runs with various q values

The appendix studies how the weighting parameter q affects VQSD training and compares six optimization algorithms. Indirectly training the operationally meaningful C1 cost with q<1 can outperform direct C1 training, while Powell is most robust but COBYLA is faster.

  • Various q values: For n = 6, 8, and 10 product states, direct C1 training with q = 1 sometimes fails to reach zero cost, whereas q = 0.5 and q = 0 approximately do so.The curves use COBYLA training and 500 simulator shots per call.
  • Various q values: Training q = 0.5 or q = 0 and then evaluating C1 achieves lower values than directly training C1.Because C1 is operationally meaningful, the improvement also has operational significance.
  • Various q values: The authors expect direct C1 training to worsen as n increases because its gradient can vanish exponentially away from minima.They always succeeded with direct C1 training for n < 6, while larger-n runs showed variability.
  • Various q values: The results support choosing q < 1 in the weighted-average cost function.The appendix presents this as numerical justification for the cost definition.
  • Optimization methods: Powell performs best overall across minimum cost, initial-condition sensitivity, and correct-solution fraction, while COBYLA and BOBYQA are next best.The study compares six optimizers on six-qubit pure product states with a one-layer, 36-parameter ansatz.
  • Optimization methods: COBYLA runs thirteen times faster than Powell on average, whereas BFGS, conjugate gradient, and Nelder-Mead fail to find minima.Nelder-Mead also has the longest average runtime; iteration counts differ from function evaluations.

Appendix F: Complexity for particular examples

The appendix evaluates diagonalization complexity for product, classically correlated, and general pure states. Circuit construction and eigenvalue readout can be efficient in important cases, but search efficiency remains unresolved for general pure states.

  • Product states: Pure product states are exactly diagonalizable with a depth-one circuit of n parallel one-qubit gates.A single ansatz layer is sufficient for this case.
  • Product states: For product states, eigenvalue readout can use a constant number of measurements independent of n.The stated estimate is ϵ_z ≈ 1/√N_readout for the relevant eigenvalue.
  • Classically correlated states: Classically correlated states also admit depth-one diagonalizing circuits, but high-entropy eigenvalue distributions can make readout scale exponentially.Thus gate and search complexities may be efficient while statistical readout is not.
  • Pure states: General pure states have efficient eigenvalue readout because N_readout can be independent of n.The appendix relates this to the earlier pure-product-state example.
  • Pure states: Efficient diagonalizing-unitary construction follows from compiling the state-preparation circuit, with two-qubit gates requiring swap-based routing.One-qubit gates translate directly into the ansatz, while routing overhead is linear per relevant two-qubit gate.
  • Pure states: For general pure states, polynomial parameter counts do not guarantee efficient optimization because the cost landscape is non-convex.The search complexity for finding a diagonalizing unitary remains an open problem.

1. Overview of qPCA

The appendix details qPCA’s use of phase estimation and density-matrix exponentiation, then implements a short-depth one-qubit circuit on noiseless and noisy simulators. Noise and additional copies reduce estimation accuracy and increase resources.

  • qPCA overview: qPCA combines quantum phase estimation with density-matrix exponentiation to estimate eigenvalues and prepare eigenvectors.The controlled evolution e^-iρt is applied at multiple times within phase estimation.
  • Implementation: The implementation approximates controlled-e^-iρt with k controlled-exponential-swap operations, using one ancilla for one-bit precision.The circuit was compiled into a short-depth sequence containing 7 CNOTs and 8 one-qubit gates.
  • qPCA overview: Approximating density-matrix exponentiation to accuracy ϵ requires O(t^2ϵ^-1) copies, yielding O(ϵ^-3) copies overall for qPCA eigenvalue and eigenvector accuracy ϵ.Phase estimation uses t_max = O(ϵ^-1).
  • Implementation: For ρ = |+⟩⟨+| on the noiseless simulator, k = 1 already estimates eigenvalues ≈{1, 0}, while the noisy simulator estimates ≈{0.8, 0.2} for k = 1.The noisy values are reported at small application times t.
  • Implementation: Using k = 2 does not improve noiseless estimation and gives ≈{0.7, 0.3} in the noisy case.The additional copy doubles the required CNOT count relative to k = 1.
  • Implementation: For one-qubit pure-state eigenvalue estimation, qPCA with k = 1 requires 3 qubits and 7 CNOT gates, versus 2 qubits and 1 CNOT for the DIP test.The appendix reports more accurate DIP-test results for this task.

Appendix H: Circuit derivation

The circuit derivation shows that the DIP test computes the diagonalized inner product between two density matrices. When both inputs are the diagonalized state, the all-zero outcome yields the squared diagonal-element sum used in the cost construction.

  • DIP test: The DIP circuit computes Tr(Z(σ)Z(τ)) for arbitrary density matrices σ and τ.The derivation begins with the product state σ⊗τ and applies the circuit’s CNOT operations.
  • DIP test: After tracing out system B, the all-zero measurement probability equals the diagonalized inner product Tr(Z(σ)Z(τ)).This follows from the relation X_z|0⟩ = |z⟩ and the diagonal entries τ_z,z.
  • DIP test: Setting σ = τ = ρ̃ makes the circuit return the sum of squares of the diagonal elements of ρ̃.This special case supplies the quantity used in the VQSD cost analysis.

2. PDIP test

The PDIP test uses CNOT-based circuits and measurements on selected qubits to evaluate reduced-state quantities. Specializing the resulting identity to identical states yields Tr(Z_j(ρ̃)^2), which connects the test to purity-related quantities.

  • The circuit in Fig. S.10(b) computes Tr(Z_j(σ)Z_j(τ)) for a specified set of qubits j.
  • The test applies CNOTs to σ ⊗ τ and traces over the control systems before measuring the selected subsystem.The selected subsystem is denoted j, with j′ its complement.
  • A Destructive Swap Test evaluates the swap-operator expectation on the post-measurement conditional state.The conditional state is obtained after the all-zeros outcome on subsystem A_j.
  • Setting σ = τ = ρ̃ specializes the identity to Tr(Z_j(ρ̃)^2).
  • The surrounding derivation relates the resulting quantities to Rényi entropy and uses subadditivity of von Neumann entropy.The order-two Rényi entropy is defined as H_2(σ) = −log_2[Tr(σ^2)].
Loading 1810.10506v2…