⚛️ quantum physics

Let the Qudit Do the Jacobi: A Structured Quantum Algorithm for Spectral Decomposition

This paper presents a structured quantum algorithm that implements Jacobi diagonalization for unknown unitary operators on qudit architectures by utilizing variational Givens rotations and an interferometric protocol to achieve eigenvalue extraction with classical-like convergence and quadratic scaling in dimension.

Original authors: A. Mandilara

Published 2026-07-16

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: A. Mandilara

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to solve a massive, tangled knot of strings. In the world of physics and math, this knot is often a "matrix," a giant grid of numbers that describes how a system behaves. Sometimes, this system is a quantum machine, a tiny device that follows the weird rules of the subatomic world. To understand what this machine is actually doing, scientists need to "untangle" the knot to find its pure, simple ingredients: its spectrum. This is called spectral decomposition. It's like taking a complex chord played on a piano and figuring out exactly which individual notes are being hit.

For decades, mathematicians have had a reliable tool for untangling these knots called the "Jacobi method." Think of it as a systematic way of pinching the knot at specific spots, twisting them just right, and repeating the process until the knot falls apart into a neat, straight line. This works great on classical computers, but when we try to do it on quantum computers, things get tricky. Quantum computers usually speak the language of "qubits" (two-state switches), but the math of these matrices often feels more natural in a language of "qudits" (multi-state switches). The big question is: Can we teach a quantum computer to untangle these knots directly, without first translating the whole problem into a boring list of numbers?

This paper, titled "Let the Qudit Do the Jacobi," introduces a clever new recipe called the Jacobi Qudit Algorithm (JQA). The authors, Aikaterini Mandilara and colleagues, propose a way to let a single quantum particle with many states (a qudit) perform the untangling dance itself. Instead of trying to read the whole matrix like a book, their algorithm treats the quantum operator as a mysterious object and gently nudges it toward a diagonal shape using a series of tiny, experimental twists.

Here is how the magic happens: In the old classical version, you would calculate exactly how much to twist a pair of numbers to fix the knot. But on a quantum computer, you can't just "calculate" the answer; you have to "feel" for it. The authors realized that instead of trying to find the perfect twist all at once (which is hard), you can break it down into two simpler steps. Imagine trying to tune a guitar string. Instead of guessing the perfect tension, you first tighten it a little, listen, then loosen it a little, listen again. The JQA does exactly this: it performs two quick, one-step "variational searches" (basically, trial-and-error experiments) to find the perfect angle to rotate a part of the system.

The team tested this idea by running simulations on a computer, using a bunch of random, complex quantum matrices (specifically, 15 different ones of size 20x20, and others up to 30x30). They found that their method worked beautifully. The "knot" untangled itself just as fast as the classical method did, and in some cases, it even needed slightly fewer rounds of twisting to get the job done. The number of steps required grew in a predictable way as the matrices got bigger, scaling with the square of the size (O(d²)), which is exactly what you'd hope for.

Crucially, this method avoids the usual headaches of quantum computing. It doesn't need to build a giant, complex machine to control the quantum states (no "controlled-unitary" operations), and it doesn't need extra helper particles (ancillas). It just uses the qudit's natural ability to rotate and a simple measurement tool to check the progress. Once the knot is untangled, the algorithm uses a special interference trick—like shining two light beams together to see a pattern—to read out the final "notes" (the eigenvalues) of the system.

The paper suggests that this approach is a perfect bridge between the old-school math of untangling matrices and the new world of quantum hardware. While the authors admit that proving this works for every single possible case is still a work in progress, their simulations show it is a robust and promising path. They also point out that while you could try to force this method to work on standard two-state qubits, it would be like trying to drive a sports car on a dirt road; it's possible, but you'd lose a lot of speed and efficiency. The method is naturally built for qudits, the multi-state stars of the quantum show.

In short, this paper doesn't just solve a math problem; it offers a new way of thinking. It shows that by borrowing a classic, structured strategy from the past and adapting it to the unique language of qudits, we can build quantum algorithms that are not only powerful but also practical and ready for the hardware of tomorrow. It's a reminder that sometimes, the best way to move forward is to take a step back, look at the old tools, and ask, "What if we tried this on a quantum machine?"

Technical Summary: A Structured Quantum Algorithm for Spectral Decomposition

Problem Statement
Spectral decomposition is a fundamental task in physics and engineering, requiring the determination of eigenvalues and eigenvectors for Hamiltonians or unitary operators. While classical numerical linear algebra offers robust methods for this, quantum approaches face a dichotomy:

Tomographic approaches: Convert the quantum operator into classical information via process tomography before applying classical algorithms. This is resource-intensive and loses the quantum nature of the operator.
Coherent approaches: Retain the operator in the quantum domain. Existing methods like Quantum Phase Estimation (QPE) require controlled-unitary operations and deep circuits, which are experimentally demanding. Variational approaches (e.g., VQE) often treat diagonalization as a global optimization problem, lacking the structured convergence guarantees of classical iterative methods.

There is a gap for a structured, iterative quantum algorithm that diagonalizes unknown unitary operators directly on quantum hardware without explicit matrix reconstruction or controlled-unitary operations, particularly one that leverages the native capabilities of higher-dimensional systems (qudits).

Methodology: The Jacobi Qudit Algorithm (JQA)
The authors propose the Jacobi Qudit Algorithm (JQA), a qudit-native realization of the classical Jacobi diagonalization method. The core philosophy is to progressively eliminate off-diagonal elements of an unknown unitary operator $M$ acting on a single $d$ -dimensional qudit through a sequence of local similarity transformations, rather than reconstructing the matrix.

Decomposition of Rotations: In the classical Jacobi algorithm for normal matrices, a two-parameter Givens rotation $U^G_{(p,q)}(\phi, \alpha)$ is applied to a $(p,q)$ sub-block to minimize off-diagonal elements. The JQA replaces this single two-parameter optimization with two sequential, single-parameter quantum variational optimizations:
1. A "real" unitary rotation $U^R_{(p,q)}(\phi_1) = \exp(i\phi_1 \hat{g}^R_{(p,q)})$ .
2. An "imaginary" unitary rotation $U^I_{(p,q)}(\phi_2) = \exp(i\phi_2 \hat{g}^I_{(p,q)})$ .
  Here, $\hat{g}^R$ and $\hat{g}^I$ are off-diagonal generators of the $su(d)$ Lie algebra.
Variational Search: The parameters $\phi_1$ and $\phi_2$ are determined experimentally via derivative-free one-dimensional searches. The algorithm minimizes a local cost function $\tau_{(p,q)}$ , defined as the sum of squared magnitudes of the off-diagonal elements in the $(p,q)$ sub-block. This is achieved by:
- Initializing the qudit in computational basis states $|p\rangle$ and $|q\rangle$ .
- Applying the rotation and measuring a single diagonal observable $B$ (with non-degenerate spectrum) to estimate the probabilities $|\langle q|\psi\rangle|^2$ .
- Repeating this to reconstruct the necessary matrix element magnitudes for the cost function without full state tomography.
Iterative Scheme: The algorithm employs a cyclic pivoting strategy. In each "sweep," every pair of indices $(p,q)$ is addressed sequentially. The process repeats until the global off-diagonal cost function $\tau(M)$ falls below a threshold.
Eigenvalue Extraction: Upon convergence, the operator is approximately diagonal. The eigenvalues (eigenphases) are extracted using an interferometric protocol. By preparing superpositions of basis states and applying the diagonalized operator followed by Hadamard-like interference operations, the phase differences between eigenvalues are estimated. The full spectrum is reconstructed up to a global phase.

Key Contributions

Structured Quantum Algorithm: The proposal of a structured, iterative algorithm for the diagonalization of unknown unitary operators on a single qudit, avoiding explicit matrix reconstruction and controlled-unitary gates.
Sequential Variational Optimization: The demonstration that the two-parameter Jacobi rotation can be decomposed into two sequential single-parameter variational searches. This mapping aligns naturally with experimentally accessible qudit operations and preserves the convergence behavior of the classical method.
Interferometric Eigenvalue Extraction: The introduction of a protocol to extract eigenvalues entirely within the quantum domain using interference, completing the diagonalization without classical post-processing of the full operator.
Empirical Scaling: Numerical verification that the algorithm exhibits convergence properties consistent with the classical Jacobi method, with the total number of pivot operations scaling as $O(d^2)$ for a prescribed accuracy.

Results
Numerical simulations were performed on ensembles of Haar-random unitary matrices with dimensions up to $d=30$ .

Convergence: The algorithm demonstrates monotonic decrease in the off-diagonal cost function. It exhibits a linear decrease in the early stages and accelerates to a quadratic convergence regime near the diagonal fixed point, mirroring the classical Jacobi method.
Sweep Count: The number of Jacobi sweeps required to reach a target accuracy (e.g., $\epsilon = 10^{-2}$ or $10^{-4}$ ) remains approximately constant (6–7 sweeps) as the dimension $d$ increases from 10 to 30.
Complexity: Since each sweep contains $O(d^2)$ pivots and the number of sweeps is constant, the total number of operations scales as $O(d^2)$ .
Comparison: The sequential single-parameter implementation (JQA) requires a comparable, and in tested instances slightly fewer, number of sweeps compared to the standard two-parameter unitary Jacobi algorithm.

Significance and Claims
The paper positions JQA not as a method to solve classical diagonalization problems faster (as the overhead of encoding classical data would negate advantages), but as a tool for the direct diagonalization of unknown quantum operators or Hamiltonians accessible experimentally but not known classically.

The authors claim the significance of this work lies in:

Bridging Classical and Quantum: Providing a structured bridge between classical iterative matrix algorithms and their quantum realizations, moving beyond global variational optimization or deep coherent circuits.
Qudit-Native Suitability: Highlighting that the algorithm is naturally suited to qudit architectures, where $SU(2)$ subgroups of $SU(d)$ can be implemented directly, avoiding the compilation overhead required for qubit-based implementations.
Experimental Feasibility: The method relies only on single-qudit rotations and measurements of a single observable, avoiding the need for ancilla qubits or controlled-unitary operations, making it suitable for near-term and early fault-tolerant devices.
Parallelizability: The structured nature of the algorithm allows for potential parallel execution of commuting rotations on disjoint subspaces, a feature relevant for distributed quantum computing.

The authors remain modest regarding the theoretical proof of convergence for the modified sequential procedure, noting that while a formal proof is unavailable, the structural similarity to the classical algorithm and numerical evidence strongly suggest the preservation of convergence properties. They also acknowledge that restricted connectivity in experimental platforms may prevent full diagonalization without additional control-theoretic synthesis.

Technical Summary: A Structured Quantum Algorithm for Spectral Decomposition

More like this