Preparing multi-qudit states in a definite-weight subspace

arXiv:2606.24659 · quant-ph · Submitted 2026-06-23 · Read on arXiv

Listen

Transcript

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

Kai: Today's paper: "Preparing multi-qudit states in a definite-weight subspace".

Mira: The gist The authors formulate a deterministic algorithm for preparing arbitrary multi-qudit states in a definite-weight subspace by ordering computational basis states according to a Gray code for multiset permutations,…

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

Paper summary: Kai: So, this paper is titled "Preparing multi-qudit states in a definite-weight subspace". Essentially, they're talking about how to deterministically prepare any arbitrary multi-qudit state within a fixed weight subspace using only elementary unitary gates.

Mira: It claims that by ordering the computational basis states according to a Gray code for multiset permutations, you can reduce the whole state preparation task down to just doing a sequence of controlled two-qudit Gray rotations.

Lev: That sounds like a neat way to tackle it. But Mira, what's the big picture here? What kind of states are we talking about?

Kai: They use this method to prepare exact eigenstates of the SU(three)-invariant Heisenberg Hamiltonian, which has a nested Bethe ansatz <ref:2606.24659#pg1,to prepare exact eigenstates of the SU(3)-invariant Heisenberg Hamiltonian>. Specifically, they describe how to prepare the Bethe states and their lower-weight descendants.

Mira: And it also extends this idea to the preparation of SU(d) Dicke states and even their q-deformations. It seems like they're showing this approach isn't just for one specific model but is quite generalizable.

Lev: If we take that generalization, we're dealing with SU(d) systems, which means the complexity scales pretty fast. I imagine the overhead of running this on real hardware would be significant if D gets large.

Kai: That's where it gets tricky, Lev. The paper says the total number of two-qudit gates and the circuit depth scales approximately as O(nD). And they flag that D can grow exponentially in some cases, leading to D scaling as d to the power of n.

Mira: Exponential scaling in D means the circuit depth could become really deep very quickly. That's a major caveat for any practical implementation on current quantum hardware, Kai.

Lev: From an engineering standpoint, if d is three or four and n gets even moderately large, that O(n d) growth for the number of gates might push us past what we can handle before error correction becomes completely impractical.

Kai: The core operation they rely on is this Gray gate, G wi,wj i,j (theta, phi), which is a qudit generalization of the qubit RBS gate and is similar to the Gray gate in other contexts. This gate performs a specific unitary transformation on computational basis states mu>i nu>j using cos(theta), sin(theta), and e i phi.

Mira: So the entire state preparation relies on implementing these specific rotations, which are dictated by those coefficients a0 through ad-one that define the arbitrary state <ref:2606.24659#pg1>. They have to invert equations three point three to figure out what those angles should be based on the target state coefficients <ref:2606.24659#pg1>.

Lev: Inverting equations is often where things get messy for real hardware control; we need high fidelity in implementing these specific rotations, and any small error in theta or phi can propagate through the whole sequence of controlled gates.

Paper summary: Kai: They apply this framework to SU(three) Bethe states, which are the highest-weight states of that Hamiltonian <ref:2606.24659#pg1>. They also show how to prepare those lower-weight descendant states using sequences of controlled gates derived from the Poincaré-Birkhoff-Witt basis.

Mira: The implication here is they can systematically generate not just the top Bethe states but any state below them, just by adjusting some amplitudes in a controlled way. That's a lot of control over the state space.

Lev: If we want to prepare those descendant states on real hardware, we're talking about chaining many gates sequentially, and that's where gate infidelity really starts to add up unless you have very robust error correction built in early on.

Kai: They also look at SU(d) Dicke states and q-deformations as examples of where this works well. The paper explicitly verifies that this circuit prepares exact SU(d) Dicke states, and they are eigenstates of the Hamiltonian HSU(d).

Mira: That's really solid evidence for the method's applicability beyond just one specific spin chain. It shows a way to tackle these integrable systems across different ranks, from SU(three) to general SU(d) <ref:2606.24659#pg1>.

Lev: So, for someone building hardware right now, this suggests that if you can engineer the control pulses to realize those qudit Gray rotations accurately, you might be able to target these specific highly symmetric states.

Kai: The discussion around Bethe states and their descendants is key because it links the algebraic structure of the Hamiltonian directly to a constructive algorithm for preparing its eigenstates. It’s not just theory; they've shown how to build them.

Mira: And I think what this means for the broader field is that we have a systematic way to generate specific, highly structured quantum states in these complex integrable models without having to rely on brute-force state preparation methods.

Lev: It's useful because it gives us a recipe for constructing the states, which is better than just hoping some random sequence of gates lands you close enough.

Kai: So to wrap up this overview of "Preparing multi-qudit states in a definite-weight subspace," we've seen how they use Gray codes to turn state preparation into controlled rotations, and how that applies to SU(three) Bethe states and Dicke states <ref:2606.24659#pg1,Preparing multi-qudit states in a definite-weight subspace>.

Mira: The authors are showing us a deterministic algorithm for preparing these structured eigenstates across different ranks of the SU algebra.

Lev: It’s a constructive method, which is always valuable because it gives you something tangible to test on real systems, even if the overhead is high as they mentioned.

Kai: This paper opens up avenues for targeting specific states in higher-rank integrable models, and it points toward the need for new nested coordinate Bethe ansatz results to handle more complex anisotropy or rank problems.

Mira: It’s a solid piece of work because it connects the mathematical structure of these models directly to a practical, though resource-intensive, preparation scheme.

Conclusion: Kai: So, this paper is about building an algorithm to make any arbitrary multi-qudit state in a definite weight subspace by using controlled rotations and Gray codes, and they're doing this for the SU(three) Heisenberg model.

Mira: They are taking these complex states, like the Bethe states of that Hamiltonian—which are high-weight—and showing you how to build them from a simple starting point using a sequence of two-qudit Gray rotations.

Lev: From an engineering standpoint, that sounds clean in theory but I gotta ask about the scale. If we're talking about preparing these states on actual hardware, how much overhead are we really looking at?

Kai: The scaling they mention is O(n d), which means for a three-qudit system, it's roughly proportional to n cubed if d is three. It’s not constant time, but it’s better than some brute-force methods.

Mira: I think the real point here is that this method connects the algebraic structure of the Bethe ansatz directly to a constructive way to get those eigenstates, which is pretty powerful for understanding these models.

Lev: But that construction depends on inverting equations they show—those angle equations—which means any tiny error in our control pulses gets magnified through that inversion process. That’s where the fidelity really matters.

Kai: So, it's a recipe for building specific states, like SU(three) Bethe states and even their lower-weight descendants, all using these controlled qudit gates.

Mira: And they’re showing this works not just for the main Bethe states but also for SU(d) Dicke states and their q-deformations, which is pretty broad coverage.

Lev: I'm curious about what this means practically—if you're building a quantum computer today, can you actually implement these Gray gates reliably enough to hit these target states?

Kai: It’s about showing that in principle, all eigenstates of the Hamiltonian corresponding to those regular solutions of the Bethe equations can be prepared this way. They even verified it for various values of n and m one, m two.

Mira: So, the big implication is that we have a deterministic roadmap for generating these highly structured quantum states in these integrable systems without just guessing or brute-forcing all possible configurations.

Lev: It gives us a way to target specific high-symmetry states directly rather than relying on messy variational methods.

Kai: This paper really lays out how you can use the structure of the underlying algebra to build up complex quantum states step by step.

Nabi Zare Harofteh, Rafael I. Nepomechie

University of Miami

quant-ph

Submitted: 2026-06-23

Updated: 2026-10-14

Comments: 21 pages, 6 figures, implementations of circuits in cirq are available on GitHub; v2: references added; v3: new appendix on noise and error detection, and more references added

Journal ref: J. Phys. A: Math. Theor. 59, 415302 (2026)

DOI: 10.1088/1751-8121/aeaf22

Code: https://github.com/nepomechie/qudit-definite-weight-states

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 87/100

The gist: The gist The authors formulate a deterministic algorithm for preparing arbitrary multi-qudit states in a definite-weight subspace by ordering computational basis states according to a Gray code for

Key concepts

Gray Code for Multiset Permutations: This is a specific ordering of computational basis states designed to simplify state preparation. Instead of preparing any state randomly, the Gray code ensures that successive states differ by only one element change in the permutation, which allows complex state preparation to be broken down into a sequence of simple, controlled operations.
Controlled 2-Qudit Gray Rotations: The core operation involves applying specific unitary transformations called Gray gates. These gates act on pairs of qubits and are generalized versions of qubit rotations. By chaining these controlled rotations according to the Gray code ordering, the algorithm systematically constructs the desired multi-qudit state from a simple starting point.
SU(3) Bethe States: These are specific, highly symmetric quantum states that are exact eigenstates of a particular Hamiltonian (the SU(3)-invariant Heisenberg model). The paper shows how their preparation is achieved using the developed algorithm. These states represent the highest-weight configurations for the SU(3) system and serve as a key example of the method's success.
Dicke States: These are specific quantum states, like SU(d) Dicke states, which are uniform superpositions of computational basis states. They are important because they are exact eigenstates of the Hamiltonian for these systems, and the algorithm is shown to prepare these exact states efficiently.

Summary

The gist The authors formulate a deterministic algorithm for preparing arbitrary multi-qudit states in a definite-weight subspace by ordering computational basis states according to a Gray code for multiset permutations, which reduces the task to performing controlled 2-qudit Gray rotations<ref:2606.24659#pg19>.

Algorithm Overview

The state preparation process is structured as follows:

The problem of preparing arbitrary multi-qudit states in a definite-weight subspace is reduced to performing a sequence of controlled 2-qudit Gray rotations.
The state (2.2) can be re-expressed as a sum over permutations with the Gray property (2.10): ψ(⃗k)⟩ = D−1 ∑ l=0 to D−1 al w[l]⟩.
The preparation involves first preparing the product state w[0]⟩, which is achieved by applying corresponding powers of X gates to the all- 0⟩ state, defined as w[0]⟩ = n∏r=1 X w[0]r r 0⟩ ⊗n.
Successive rotations are performed using the transformation: w[l]⟩ → cos(θl)∣w[l]⟩ + e iϕl sin(θl)w[l+1]⟩, for l = 0, 1,...,D − 2.
The required rotation angles are determined by inverting the equations (3.3) to express them in terms of the specified coefficients a0,..., aD−1.

Gray Gate Implementation

The core operation is the Gray gate G wi,wj i,j (θ, ϕ), which performs the desired n-qudit transformation (3.2). This gate is a qudit generalization of the qubit RBS gate in [14] and is similar to the Gray gate in [28]. The transformation G wi,wj i,j (θ, ϕ) (3.7) acts on computational basis states µ⟩ i ν⟩ j with specific unitary operations involving cos(θ), sin(θ), and e iϕ.

State Preparation Efficiency

The total number of two-qudit gates and the circuit depth scale approximately as O(nD). The dominant factor is D, which can grow exponentially in the worst case where ⃗k ∼ (n d, n d,..., n d), leading to D ∼ d n.

Applications to Dicke States

The algorithm has simple applications for SU(d) Dicke states D n⃗k⟩ and SUq(d) Dicke states D nq⃗k⟩, which are defined as uniform superpositions of weight-⃗k computational basis states. These states are eigenstates of the U(1) operators K(i), with eigenvalues k i K(i) ψ(⃗k)⟩ = k i ψ(⃗k)⟩. The authors explicitly verified that this circuit prepares the exact states D n⃗k⟩, and they are eigenstates of the Hamiltonian HSU(d).

Bethe States and Descendants

The algorithm can prepare SU(3) Bethe states, which are SU(3) highest-weight states. Furthermore, the lower-weight descendant states can be prepared similarly to the Bethe states except with different amplitudes. For SU(3), the Bethe roots are solutions of a system of equations (6.7)-(6.8).

Discussion and Limitations

The approach exploits Gray codes to reduce state preparation to controlled 2-qudit Gray rotations, similar to methods for fixed Hamming-weight subspaces. However, the coordinate-Bethe-ansatz approach has a high classical overhead for computing the coefficients a w and angles of the Gray rotations. This makes it not practical for large system sizes. The authors suggest that new nested coordinate Bethe ansatz results may be needed to prepare eigenstates of other integrable models with anisotropy or higher rank.

SU(d) Dicke States and Symmetry

The SU(d) Dicke states D n⃗k⟩ are eigenstates of the Hamiltonian HSU(d). The q-deformed states D nq⃗k⟩ are also eigenstates of a q-deformation of the Hamiltonian HSUq(d). The authors explicitly verified that the circuit (3.17) prepares exact states D nq⃗k⟩, and they are eigenstates of the Hamiltonian HSUq(d).

Descendant States Preparation

The SU(3) descendant states can be prepared by applying lowering operators (E 10, E 20, E 21) to the on-shell Bethe states using a sequence of controlled gates derived from the Poincaré-Birkhoff-Witt (PBW) basis. The resulting descendant states are given by (B.17).

Final Conclusion on Preparation

In principle, all eigenstates of the Hamiltonian (6.1) corresponding to regular solutions of the Bethe equations can be prepared in this way. The authors have explicitly verified that the circuit (3.17) indeed prepares exact eigenstates of the Hamiltonian (6.1), with corresponding eigenvalue (6.10), for various values of n, m1, m2.

--- Page 2 ---

The problem of preparing a given multi-qubit quantum state on a quantum computer, using only elementary unitary gates, is an important task in quantum computing[1]. The problem of preparing exact eigenstates (so-called Bethe states) of the spin-1/2 XXZ chain, which are given by the Bethe ansatz [2–4], has drawn considerable recent attention [5–13]. Since these states are also U(1)-eigenstates, they have fixed Hamming weight; hence, algorithms for preparing arbitrary states in a fixed Hamming-weight subspace [10, 14–17] can in particular be used to prepare such Bethe states<ref:2606.24659#pg3>. An elegant yet straightforward approach for preparing states in a fixed Hamming-weight subspace, formulated in [14], is to order the corresponding computational basis states according to a so-called Gray code1, which reduces the state-preparation task to performing a sequence of controlled 2-qudit rotations. Since integrable spin-s (where s ∈ [1/2, 1, 3/2,...]) generalizations of the XXX model are known [22–27], it is natural to consider the problem of preparing the corresponding spin-s Bethe states. These states are also U(1)-eigenstates, and therefore have fixed digit sum (rather than fixed Hamming weight, which is limited to the s = 1/2 case). An algorithm for preparing arbitrary spin-s U(1)-eigenstates (and in particular spin-s Bethe states) was recently formulated in [28], based on a Gray code for bounded integer compositions[29]. The integrable spin-s XXX models are based on SU(2), whose algebra has rank one. Many higher-rank integrable models are also known, see e.g. [30–33]. It is therefore also natural to consider the problem of preparing Bethe states for such higher-rank models, where the so-called nesting phenomenon appears[30, 2606.2465948]. One of our main goals here is to address this problem for the simplest such model, namely, the SU(3)-invariant Heisenberg chain with periodic boundary conditions.

Improvements for AI systems

textbf Processing of arbitrary multi-qudit states in definite-weight subspaces: The improved AI system can deterministically prepare arbitrary multi-qudit states in a definite-weight subspace by ordering computational basis states according to a Gray code for multiset permutations.
textbf Preparation of SU(3) Bethe states: The system can prepare exact eigenstates of the SU(3)-invariant Heisenberg Hamiltonian by implementing the algorithm described, which involves a sequence of controlled 2-qudit Gray rotations.
textbf Generation of descendant states: The AI can prepare lower-weight descendants of Bethe states by applying the transformations described in Appendix B, allowing for a complete preparation of SU(3) irreducible representations.
textbf Qudits and Hamiltonian Symmetry Exploitation: The system can exploit the high degree of symmetry in SU(d) Dicke states to prepare them more efficiently, leveraging their eigenstates of the U(1) operators (2.8).
textbf q-Deformed State Preparation: The AI can prepare SUq(d) Dicke states by utilizing the structure derived from the q-multinomial coefficients and inversion numbers, which generalizes SU(d) Dicke states for complex q values.