Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

Widening the Bit: Extending QCLAB to Qudits and Generalizing State Preparation

SIMONE IANNICIELLO

Published Oct 10, 2026• 0 citations
OpenAlex

Abstract

The research on qudits, which are the d-level generalization of qubits, as of now is in very early stages, in particular from the software and simulation point of view. This thesis actively extends QCLAB, the MATLAB toolbox for quantum circuits simulation, to qudits of arbitrary dimension d by introducing the necessary circuit representation and simulation as well as gates, building on top of the original functionalities. As a case study, we use the extended tool for qudit state preparation: building a circuit that loads a given vector into a quantum register. We implement the Bullock, O'Leary, and Brennen state preparation construction, which is optimal in gate count, and generalize the KP-Tree data structure and the associated state preparation method of Kerenidis and Prakash to qudits. The generalized method comes in two variants, built on Givens rotations and on Householder reflectors. Under the QRAM model, the Householder variant loads a state with fewer memory queries than the qubit KP-Tree. We validate the correctness of the constructions across several qudit dimensions.

Related papers

qiskit-qudits: A Qiskit Extension for Simulating Qudit Circuits

Francesco Pudda

qiskit-qudits is a Qiskit extension that simulates d-level qudits by encoding each one into m = ceil(log_2 d) qubits. Qudit gates are exposed as ordinary Qiskit Gate and ControlledGate subclasses, and operations that are not unitary gates (measurement, reset, barrier, state preparation) as dedicated Instruction subclasses dispatched through a dedicated apply() hook; every gate carries both a dense encoded unitary (via NumPy's array protocol) and a qubit-level definition. Because d need not be a power of two, the encoded Hilbert space is generally larger than the logical one; the library resolves this by the identity-padding convention, in which every gate acts as the identity on the unphysical part of the encoded space. When every operand dimension is a power of two, gates decompose into a fixed, transpiler-recognisable cascade of standard qubit gates; otherwise the library falls back to exact dense unitary synthesis, so that dimensions 2 <= d <= 16 are supported exactly, not only powers of two. This paper describes the software's circuit model, gate hierarchy, decomposition strategy, and measurement/decoding machinery, states its limitations, and verifies the implementation numerically: the qudit QFT against the discrete Fourier transform for both power-of-two and non-power-of-two d, extending the check of the underlying theory paper, which could only be run for d = 2^m, and every gate's emitted decomposition against its dense unitary across the whole gate set.

quant-pharXiv:2608.22032•Aug 25, 2026•0 citations

QFlux: Quantum Circuit Implementations of Molecular Dynamics. Part III - State Initialization and Unitary Decomposition

Alexander V. Soudackov, Delmar G. A. Cabral, Brandon Allen +7 more

This tutorial builds upon the foundations established in Part~II to present a unified, implementation-oriented overview of quantum state initialization and unitary decomposition for n -qubit systems, available in QFlux . We begin with the preparation of arbitrary quantum states and develop two complementary constructions: (i) a recursive multiplexor method (after Shende et al.) that disentangles qubits via multiplexed R y and R z rotations, and (ii) an algebraic scheme based on uniformly controlled rotations (UCRs) (after Möttönen et al.) that realizes the same mapping through analytically defined rotation networks with predictable gate counts. We then extend these state-preparation tools to generic unitary synthesis through Givens-rotation, column-by-column, and recursive cosine-sine (CSD) and quantum Shannon (QSD) decompositions, explicitly linking linear-algebraic factorizations to executable circuits while tracking CNOT complexity. Finally, we introduce the Walsh decomposition for diagonal unitaries and show how Gray-code ordering and local CNOT cancellations yield an O(2^n) entangling-gate cost, providing shallow, NISQ-friendly implementations. Taken together, these techniques form a pedagogical bridge from matrix analysis to hardware-efficient circuit constructions, offering clear design rules, closed-form parameters, and scalable synthesis pathways for simulation and experiment.

•Jan 30, 2026•0 citations

Building an effective general-purpose quantum simulator for the design and analysis of quantum circuits

Michael Anshel, Anh Quoc Nguyen

Recently quantum computing has achieved significant results both in theoretical and experimental areas and quantum algorithms have drawn the attention of many scientists. At the present there exist several experiments that realized some parts of certain important quantum algorithms. While those experiments work with only up to seven qubits, quantum simulators allow scientists to design algorithms with many more qubits. The existing simulators have one or more of the following restrictions: either they require powerful computers and additional computation packages such as Matlab or Mathematica or they don't provide an easy method for interacting between the classical and quantum parts of an algorithm. More importantly, none of them can simulate a generic 64-qubit circuit. It is important at this stage of quantum computing development to investigate technological improvements in simulating quantum circuit design. In this thesis we developed a specialized data structure, QSV, for quantum simulators along with new method for calculation of the new state vector after application of a quantum gate in a quantum simulator. We also developed a technique that speeds up the simulation time with our QSV vectors. With those results we built a quantum simulator that overcomes many shortcomings in other simulators and it has many advanced features. Our simulator can simulate many 64-qubit circuits and it can directly simulate multiple qubit gates as well as allows users to define gates with up to 10 qubits. The simulation time is much less in comparison with other simulators we tested. The simulator defines specifications so that users can easily design and test quantum circuits. With the simulator we also developed some new quantum circuits and verified many designs and constructions.

•Jan 1, 2006•0 citations

Qudit Designs and Where to Find Them

Namit Anand, Jeffrey Marshall, Jason Saied +2 more

Unitary t-designs are some of the most versatile tools in quantum information theory. Their applications range from randomized benchmarking and shadow tomography, to more fundamental ones such as emulating quantum chaos and establishing exponential separations between classical and quantum query complexity. While unitary designs originating from a group structure, such as the Clifford group, have proven to be incredibly useful for qubit systems, unfortunately, this is no longer true for qudits. In fact, the classification of finite-group representations rules out the existence of unitary 2-designs for arbitrary qudit dimensions. This severely limits the applicability of standard quantum information primitives when it comes to qudit systems. We overcome these limitations with a three-fold contribution. First, we introduce a general technique to construct families of weighted state t-designs in arbitrary qudit dimensions. These weighted state-designs generalize classical shadow tomography protocol from qubits to qudits. Second, we introduce a Clifford character RB that allows us to benchmark the qudit Clifford group in any dimension, including non-prime-power dimensions. And third, we establish bounds on the quantum circuit complexity of generating approximate unitary-designs from native gates in existing quantum hardware such as high-spin and cavity-QED qudits. Our work further highlights the analogy between spin and optical coherent states by proving that spin-GKP codewords form a state 2-design while spin coherent states do not; in direct analogy with the optical case. This work is structured as a pedagogical and self-contained introduction to unitary designs and their applications to qudit systems.

quant-pharXiv:2603.02659•Mar 4, 2026•3 citations

Efficient circuits for exact-universal computation with qudits

Gavin K. Brennen, Stephen S. Bullock, Dianne Prost O’Leary

This paper concerns the efficient implementation of quantum circuits for qudits. We show that controlled two-qudit gates can be implemented without ancillas and prove that the gate library containing arbitrary local unitaries and one two-qudit gate, $\CINC$, is exact-universal. A recent paper [S.Bullock, D.O'Leary, and G.K. Brennen, Phys. Rev. Lett. 94, 230502 (2005)] describes quantum circuits for qudits which require O(d^n) two-qudit gates for state synthesis and O(d^{2n}) two-qudit gates for unitary synthesis, matching the respective lower bound complexities. In this work, we present the state-synthesis circuit in much greater detail and prove that it is correct. Also, the (n-2)/(d-2) ancillas required in the original algorithm may be removed without changing the asymptotics. Further, we present a new algorithm for unitary synthesis, inspired by the QR matrix decomposition, which is also asymptotically optimal.

arXiv:quant-ph/0509161•Quantum Information and Computation•Jul 1, 2006•39 citations

Parallelism for quantum computation with qudits

Dianne Prost O’Leary, Gavin K. Brennen, Stephen S. Bullock

Robust quantum computation with $d$-level quantum systems (qudits) poses two requirements: fast, parallel quantum gates and high-fidelity two-qudit gates. We first describe how to implement parallel single-qudit operations. It is by now well known that any single-qudit unitary can be decomposed into a sequence of Givens rotations on two-dimensional subspaces of the qudit state space. Using a coupling graph to represent physically allowed couplings between pairs of qudit states, we then show that the logical depth (time) of the parallel gate sequence is equal to the height of an associated tree. The implementation of a given unitary can then optimize the tradeoff between gate time and resources used. These ideas are illustrated for qudits encoded in the ground hyperfine states of the alkali-metal atoms $^{87}\mathrm{Rb}$ and $^{133}\mathrm{Cs}$. Second, we provide a protocol for implementing parallelized nonlocal two-qudit gates using the assistance of entangled qubit pairs. Using known protocols for qubit entanglement purification, this offers the possibility of high-fidelity two-qudit gates.

arXiv:quant-ph/0603081•Physical Review A•Sep 28, 2006•61 citations
The research on qudits, which are the d-level generalization of qubits, as of now is in very early stages, in particular from the software and simulation point of view. This thesis actively extends QCLAB, the MATLAB toolbox for quantum circuits simulation, to qudits of arbitrary dimension d by introducing the necessary circuit representation and simulation as well as gates, building on top of the original functionalities. As a case study, we use the extended tool for qudit state preparation: building a circuit that loads a given vector into a quantum register. We implement the Bullock, O'Leary, and Brennen state preparation construction, which is optimal in gate count, and generalize the KP-Tree data structure and the associated state preparation method of Kerenidis and Prakash to qudits. The generalized method comes in two variants, built on Givens rotations and on Householder reflectors. Under the QRAM model, the Householder variant loads a state with fewer memory queries than the qubit KP-Tree. We validate the correctness of the constructions across several qudit dimensions.
qiskit-qudits is a Qiskit extension that simulates d-level qudits by encoding each one into m = ceil(log_2 d) qubits. Qudit gates are exposed as ordinary Qiskit Gate and ControlledGate subclasses, and operations that are not unitary gates (measurement, reset, barrier, state preparation) as dedicated Instruction subclasses dispatched through a dedicated apply() hook; every gate carries both a dense encoded unitary (via NumPy's array protocol) and a qubit-level definition. Because d need not be a power of two, the encoded Hilbert space is generally larger than the logical one; the library resolves this by the identity-padding convention, in which every gate acts as the identity on the unphysical part of the encoded space. When every operand dimension is a power of two, gates decompose into a fixed, transpiler-recognisable cascade of standard qubit gates; otherwise the library falls back to exact dense unitary synthesis, so that dimensions 2 <= d <= 16 are supported exactly, not only powers of two. This paper describes the software's circuit model, gate hierarchy, decomposition strategy, and measurement/decoding machinery, states its limitations, and verifies the implementation numerically: the qudit QFT against the discrete Fourier transform for both power-of-two and non-power-of-two d, extending the check of the underlying theory paper, which could only be run for d = 2^m, and every gate's emitted decomposition against its dense unitary across the whole gate set.
This tutorial builds upon the foundations established in Part~II to present a unified, implementation-oriented overview of quantum state initialization and unitary decomposition for n -qubit systems, available in QFlux . We begin with the preparation of arbitrary quantum states and develop two complementary constructions: (i) a recursive multiplexor method (after Shende et al.) that disentangles qubits via multiplexed R y and R z rotations, and (ii) an algebraic scheme based on uniformly controlled rotations (UCRs) (after Möttönen et al.) that realizes the same mapping through analytically defined rotation networks with predictable gate counts. We then extend these state-preparation tools to generic unitary synthesis through Givens-rotation, column-by-column, and recursive cosine-sine (CSD) and quantum Shannon (QSD) decompositions, explicitly linking linear-algebraic factorizations to executable circuits while tracking CNOT complexity. Finally, we introduce the Walsh decomposition for diagonal unitaries and show how Gray-code ordering and local CNOT cancellations yield an O(2^n) entangling-gate cost, providing shallow, NISQ-friendly implementations. Taken together, these techniques form a pedagogical bridge from matrix analysis to hardware-efficient circuit constructions, offering clear design rules, closed-form parameters, and scalable synthesis pathways for simulation and experiment.
Recently quantum computing has achieved significant results both in theoretical and experimental areas and quantum algorithms have drawn the attention of many scientists. At the present there exist several experiments that realized some parts of certain important quantum algorithms. While those experiments work with only up to seven qubits, quantum simulators allow scientists to design algorithms with many more qubits. The existing simulators have one or more of the following restrictions: either they require powerful computers and additional computation packages such as Matlab or Mathematica or they don't provide an easy method for interacting between the classical and quantum parts of an algorithm. More importantly, none of them can simulate a generic 64-qubit circuit. It is important at this stage of quantum computing development to investigate technological improvements in simulating quantum circuit design. In this thesis we developed a specialized data structure, QSV, for quantum simulators along with new method for calculation of the new state vector after application of a quantum gate in a quantum simulator. We also developed a technique that speeds up the simulation time with our QSV vectors. With those results we built a quantum simulator that overcomes many shortcomings in other simulators and it has many advanced features. Our simulator can simulate many 64-qubit circuits and it can directly simulate multiple qubit gates as well as allows users to define gates with up to 10 qubits. The simulation time is much less in comparison with other simulators we tested. The simulator defines specifications so that users can easily design and test quantum circuits. With the simulator we also developed some new quantum circuits and verified many designs and constructions.
Unitary t-designs are some of the most versatile tools in quantum information theory. Their applications range from randomized benchmarking and shadow tomography, to more fundamental ones such as emulating quantum chaos and establishing exponential separations between classical and quantum query complexity. While unitary designs originating from a group structure, such as the Clifford group, have proven to be incredibly useful for qubit systems, unfortunately, this is no longer true for qudits. In fact, the classification of finite-group representations rules out the existence of unitary 2-designs for arbitrary qudit dimensions. This severely limits the applicability of standard quantum information primitives when it comes to qudit systems. We overcome these limitations with a three-fold contribution. First, we introduce a general technique to construct families of weighted state t-designs in arbitrary qudit dimensions. These weighted state-designs generalize classical shadow tomography protocol from qubits to qudits. Second, we introduce a Clifford character RB that allows us to benchmark the qudit Clifford group in any dimension, including non-prime-power dimensions. And third, we establish bounds on the quantum circuit complexity of generating approximate unitary-designs from native gates in existing quantum hardware such as high-spin and cavity-QED qudits. Our work further highlights the analogy between spin and optical coherent states by proving that spin-GKP codewords form a state 2-design while spin coherent states do not; in direct analogy with the optical case. This work is structured as a pedagogical and self-contained introduction to unitary designs and their applications to qudit systems.
This paper concerns the efficient implementation of quantum circuits for qudits. We show that controlled two-qudit gates can be implemented without ancillas and prove that the gate library containing arbitrary local unitaries and one two-qudit gate, $\CINC$, is exact-universal. A recent paper [S.Bullock, D.O'Leary, and G.K. Brennen, Phys. Rev. Lett. 94, 230502 (2005)] describes quantum circuits for qudits which require O(d^n) two-qudit gates for state synthesis and O(d^{2n}) two-qudit gates for unitary synthesis, matching the respective lower bound complexities. In this work, we present the state-synthesis circuit in much greater detail and prove that it is correct. Also, the (n-2)/(d-2) ancillas required in the original algorithm may be removed without changing the asymptotics. Further, we present a new algorithm for unitary synthesis, inspired by the QR matrix decomposition, which is also asymptotically optimal.
Robust quantum computation with ddd-level quantum systems (qudits) poses two requirements: fast, parallel quantum gates and high-fidelity two-qudit gates. We first describe how to implement parallel single-qudit operations. It is by now well known that any single-qudit unitary can be decomposed into a sequence of Givens rotations on two-dimensional subspaces of the qudit state space. Using a coupling graph to represent physically allowed couplings between pairs of qudit states, we then show that the logical depth (time) of the parallel gate sequence is equal to the height of an associated tree. The implementation of a given unitary can then optimize the tradeoff between gate time and resources used. These ideas are illustrated for qudits encoded in the ground hyperfine states of the alkali-metal atoms 87Rb^{87}\mathrm{Rb}87Rb and 133Cs^{133}\mathrm{Cs}133Cs. Second, we provide a protocol for implementing parallelized nonlocal two-qudit gates using the assistance of entangled qubit pairs. Using known protocols for qubit entanglement purification, this offers the possibility of high-fidelity two-qudit gates.