Quantum oblique eigenprojection

arXiv:2609.40254 · quant-ph, cs.DS, physics.chem-ph · Submitted 2026-09-30 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.

Kai: Today's paper: "Quantum oblique eigenprojection".

Mira: Every square matrix decomposes its underlying Hilbert space into generalized eigensubspaces,

Kai: First, who's behind it and why it matters.

Title and authors: Kai: So, we're starting with the paper "Quantum oblique eigenprojection," and I want to give everyone a quick rundown on what it is. Basically, this work tackles a problem where you need to project onto generalized eigensubspaces of square matrices in quantum systems, which turns out to be a nonanalytic operation when the spectrum is complex.

Mira: From my side, the title immediately tells us we're dealing with something that goes beyond standard eigenvalue problems because it involves projections that aren't smooth functions of a complex variable, which is where things get tricky for analytic methods.

Lev: And from an error correction standpoint, if this actually runs on hardware, we need to consider how stable the block encoding and the preconditioning are when dealing with those non-Hermitian aspects mentioned in the abstract.

Kai: Exactly; it shows that a quantum computer can handle this oblique eigenprojection given block encoding access to the input matrix, and they claim their query complexity is nearly linear in the inverse gap.

Mira: That linear scaling is interesting because standard methods usually have a much larger normalization factor driven by that inverse gap, so reducing it close to the optimal value is a significant technical hurdle they've managed to clear.

Lev: If we're talking about real hardware, I worry about how robust this preconditioning technique holds up when the spectral set conditions aren't perfectly met in practice.

Kai: Well, the paper suggests that these spectral-set conditions can be satisfied under common assumptions like diagonalizability or numerical range separation, which makes it more practical for experimental setups.

The paper's summary: Mira: Now, looking at the summary of "Quantum oblique eigenprojection," it really boils down to overcoming the analytic obstruction that prevents direct polynomial or singular value implementations when dealing with complex spectra.

Kai: That's the core difficulty they identified; they are showing how a quantum computer can bypass that obstruction by using a specific technique involving block encoding access to the input matrix.

Lev: I wonder how this relates to the standard approach we see in time evolution, which often requires evolving out to time t = (one/delta) just to get an estimate, as mentioned in page two of THIS PAPER.

Mira: Precisely; the standard resolvent integration introduces a normalization factor alpha = (/ delta), which is much larger than what they are aiming for, and this paper introduces a two-sided block preconditioning using the discrete Fourier transform of the matrix resolvent to fix that.

Kai: So, the main summary point is that this preconditioning suppresses that inverse-gap growth down to nearly while keeping the same query complexity as standard block encoding methods based on resolvent integration.

Lev: If you can achieve a normalization factor close to optimal without increasing the overall complexity beyond what's already achievable with block encodings, that makes it much more viable for actual implementation.

Mira: It suggests that for complex spectra, we don't necessarily need to rely on those large resolvent integrals if we can use this Fourier-based preconditioning to manage the projection more directly.

Kai: So, the paper summarizes by showing that under spectral-set conditions, they can achieve a normalization factor close to, which is essentially what they needed for their method to be effective.

The paper's improvements: Kai: Moving on to the actual improvements this paper proposes, it highlights that their two-sided block preconditioning technique is key because it resolves the inefficiency of standard approaches by characterizing every block through a discrete Fourier transform of the matrix resolvent.

Mira: That transforms a problem involving an indicator function into one where they can exploit a circulant structure, which then allows them to suppress the inverse-gap growth of the normalization factor down to nearly.

Lev: From an error correction viewpoint, if this preconditioning is effective, it means we might be able to run these projections on real hardware with less noise accumulation because the required precision for normalization is much lower.

Kai: They prove that under the numerical-range assumption, the normalization factor alpha res becomes O(in / delta num), and under diagonalizability, it scales as O(kappa V in / delta eig).

Mira: Those scaling bounds are important because they show how the performance depends on the specific spectral set conditions assumed, linking the theoretical bound directly to assumptions about the matrix properties.

Lev: If you can get alpha res close to in, that translates directly into a massive reduction in required precision for those intermediate steps, which is crucial when talking about fault-tolerant computation.

Kai: Beyond just the normalization factor, they also show this primitive is a general tool; they extend the algorithm to more general regions of the complex plane using a separating map f and the unit-disk construction applied to f(A).

Mira: That generalization is what makes it powerful because it allows projections onto any region whose boundary separates the spectrum, provided that map f is analytic on neighborhoods of the relevant block numerical ranges and satisfies modulus separation conditions.

Conclusion: Kai: To wrap up, "Quantum oblique eigenprojection" concludes that they can implement this oblique eigenprojection efficiently on a quantum computer with query complexity nearly linear in the inverse gap and a normalization factor close to its optimal value.

Mira: So, the implication is that this resolvent-based construction is a promising route for applying nonanalytic matrix functions on quantum computers because it controls the resolvent on the boundary of the region instead of requiring uniform approximation.

Lev: For real hardware, this suggests we can move away from those methods where you need to evolve out to time t = (one/delta) and instead use this more targeted projection method for tasks like solving continuous-time algebraic Riccati equations or Sylvester equations.

Kai: That's the practical application: preparing eigenstates of matrices with complex eigenvalues, solving Riccati equations with a cubic speedup over prior solvers, and quadratically improving direct augmented methods for Sylvester equations.

Mira: The potential impact is that this opens up applying nonanalytic matrix functions to quantum computers in ways that were previously ruled out by the analytic obstruction, which is a significant theoretical step.

Lev: I just want to stress that while the paper shows the method, running it on real hardware requires careful management of those spectral-set conditions, because if you violate them, you lose all the benefits they've described regarding normalization factors.

Alexander M. Dalzell, Yuan Su

AWS Center for Quantum Computing

quant-ph, cs.DS, physics.chem-ph

Submitted: 2026-09-30

Updated: 2026-09-30

Comments: 41 pages, 3 figures

License: http://creativecommons.org/licenses/by-sa/4.0/

Importance score: 83/100

The gist: Every square matrix decomposes its underlying Hilbert space into generalized eigensubspaces, and this paper demonstrates how a quantum computer can perform an oblique eigenprojection given block

Key concepts

Oblique Eigenprojection
This is a specific quantum operation used to project onto regions in the complex plane that are not easily handled by standard methods. It's crucial for finding eigenstates of matrices that have complex eigenvalues, which is often impossible with simpler techniques.
Analytic Obstruction
This refers to a mathematical barrier that prevents direct polynomial approximations from working when dealing with complex spectra. The maximum modulus principle stops these approximations from accurately representing the desired projection in certain directions, forcing researchers to use more complex techniques.
Two-Sided Block Preconditioning
This is the main technical innovation. It involves using a discrete Fourier transform of the matrix resolvent to characterize every block of the input matrix. This technique effectively suppresses the growth of a normalization factor that usually grows too large, bringing it down close to its optimal value.
Resolvent Integration
This is a standard approach where projections are calculated by integrating over the resolvent of the matrix. The paper shows how to improve this method by using block preconditioning to control the resulting normalization factor, making it more efficient than traditional integration methods.

Terminology

Summary

Every square matrix decomposes its underlying Hilbert space into generalized eigensubspaces, and this paper demonstrates how a quantum computer can perform an oblique eigenprojection given block encoding access to the input matrix. This work is significant because it provides a method to apply nonanalytic matrix functions on quantum computers by overcoming the analytic obstruction that rules out direct polynomial or singular value implementations.

The gist

A quantum computer can perform such an oblique eigenprojection given block encoding access to the input matrix, with a query complexity nearly linear in the inverse gap and a normalization factor close to∥Π∥ under a spectral-set condition on the input.

Standard Approach and Obstruction

The problem of performing an oblique eigenprojection is fundamentally difficult because it involves approximating the indicator function of a target region in the complex plane, which is nonanalytic when the spectrum is complex. While polynomial approximations work for real spectra, they are obstructed in every direction for complex spectra by the maximum modulus principle. The standard approach to implement this projection via resolvent integration introduces a normalization factor α = Θ(∥Π∥ /δ), where δ is the gap between the spectrum and the target region boundary, which is much larger than the desired normalization factor ∥Π∥.

Two-Sided Block Preconditioning

The main technical contribution is a two-sided block preconditioning that employs a discrete Fourier transform of the matrix resolvent. This technique resolves the inefficiency of standard approaches by characterizing every block through this transform, which exposes a circulant structure. The preconditioning suppresses the inverse-gap growth of the normalization factor down to nearly∥Π∥, while maintaining the same query complexity as standard block encoding methods based on resolvent integration.

Key Results and Bounds

The analysis relies on establishing spectral-set conditions for compressions of the invariant subspaces, which are satisfied under common assumptions like numerical range separation or diagonalizability. The paper proves that under these conditions, the normalization factor is reduced to nearly its optimal value ∥Π∥. Specifically:

  1. Under the numerical-range assumption, αres = O(∥Πin∥ /δnum).

  2. Under the diagonalizability assumption, αres = O(κV ∥Πin∥ /δeig).

Applications

The developed oblique eigenprojection primitive is shown to be a general-purpose tool with concrete improvements in several areas:

  1. Preparing eigenstates of matrices with complex eigenvalues, extending the Quantum EigenValue Transformation algorithm beyond real spectra.

  2. Solving continuous-time algebraic Riccati equations, achieving a cubic speedup over prior solvers by removing normalization factors driven by the inverse gap.

  3. Solving ordinary Sylvester equations, quadratically improving a direct augmented method by replacing the resolvent-integral normalization factor αres = O(∥Πin∥ /δ) with one close to its optimal value ∥Πin∥.

Generalization to Arbitrary Regions

The algorithm is extended to more general regions of the complex plane using a separating map f, which transforms the problem into an instance of the unit-disk construction applied to f(A). This allows for projections onto any region whose boundary separates the spectrum, provided that f is analytic on neighborhoods of the relevant block numerical ranges and satisfies modulus separation conditions. This approach demonstrates a promising route toward applying more general nonanalytic matrix functions on quantum computers.

Cost Analysis

The two-sided preconditioning leads to a normalized projection with normalization factor αΠ = O(c∥Πin∥), where c is related to the spectral set constant (e.g., 1 + √2 for numerical ranges). The total query complexity is governed by O(c αA∥Πin∥δ log c∥Πinε log 1/ε) queries, which balances the discretization error against the condition number growth, resulting in a near-optimal normalization factor and query cost. This matches known results for orthogonal eigenprojections while improving the cost of subroutines like Riccati equation solvers by a quadratic to cubic factor.

Final Conclusion

The research concludes that the oblique eigenprojection can be implemented efficiently on a quantum computer with query complexity nearly linear in the inverse gap and a normalization factor close to its optimal value ∥Π∥, suggesting that this resolvent-based construction is a promising route for applying nonanalytic matrix functions on quantum computers. The method controls the resolvent on the boundary of the region rather than requiring uniform approximation, making it applicable where direct polynomial methods fail.

References

[1] Daniel S. Abrams and Seth Lloyd, Quantum algorithm providing exponential speed increase for finding eigenvalues and eigenvectors, Physical Review Letters 83 (1999), 5162–5165, arXiv:quant-ph/9807070.

[2] Abhijeet Alase and Salini Karuvade, Resolvent-based quantum phase estimation: Towards estimation of parametrized eigenvalues, 2024, arXiv:2410.

Improvements for AI systems

Based on the scientific paper Quantum oblique eigenprojection, here are specific, high-impact improvements for AI systems:

The core contribution of this paper is a method to perform non-analytic matrix functions (like indicator functions of spectral regions) on quantum computers with near-optimal query complexity, specifically by improving the normalization factor from an inverse gap dependence to a nearly optimal value.

Here are the specific improvements and capabilities for an enhanced AI system:

  1. The system can efficiently prepare eigenstates of non-Hermitian or non-normal systems (e.g., those arising in quantum chemistry or irreversible Markov chains) with a cost scaling as well as Hermitian systems, achieving a complexity matching the optimal linear gap scaling, rather than the slower quadratic resolvent-integral approach.

  2. The system can solve continuous-time algebraic Riccati equations (central to optimal control and filtering) by reducing their query complexity from cubic improvement (as in prior solvers) to a near-optimal scaling of only 1/δ, offering a significant speedup in real-time decision-making applications.

  3. The system can solve Sylvester equations (used in control theory and model reduction) with a quadratic improvement over existing direct augmented methods, achieving query complexity scaling as O(1/δ2) instead of O(1/δ), leading to faster solution times for complex systems.

  4. The system can perform arbitrary matrix functions on quantum computers by leveraging a separating map technique (using rational functions like the degree-two map in Section 4.2) combined with the unit-disk construction, enabling projection onto any desired spectral region defined by an analytic boundary, rather than being restricted to real spectra.

In summary, the improved AI system can:

  • Perform high-fidelity state preparation for complex physical systems (non-Hermitian physics).

  • Solve continuous control problems (Riccati equations) with higher efficiency and lower computational cost.

  • Rapidly solve linear matrix equations (Sylvester equations) for complex dynamical systems.

  • Generalize quantum computation to handle nonanalytic functions of general matrices, expanding the scope of what is computable on quantum hardware beyond analytic functions.

Abstract

Every square matrix decomposes its underlying Hilbert space into generalized, nonorthogonal eigensubspaces. We show that a quantum computer can perform such an oblique eigenprojection Π given block encoding access to the input matrix. Our approach has a query complexity nearly linear in the inverse gap and a normalization factor close to Π under a spectral-set condition on the input. This covers common assumptions on the numerical range or diagonalizability and matches known results for orthogonal eigenprojections. We achieve this with a two-sided block preconditioning that uses a discrete Fourier transform of the matrix resolvent. We describe applications to: (i) preparing eigenstates of matrices with complex eigenvalues, extending the quantum eigenvalue transformation algorithm of Low and Su beyond real spectra; (ii) solving continuous-time algebraic Riccati equations, cubically speeding up a prior solver of Rodenas-Ruiz, Zhao, and Lee; and (iii) solving ordinary Sylvester equations, quadratically improving a direct augmented method of Wang and Liu. Our result suggests a promising route to applying nonanalytic matrix functions on quantum computers.

Sources

Related papers