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

arXiv:2609.23243

Resource and entanglement study of a hybrid qudit-qubit quantum algorithm for solving the integer programming problem

Kapil Goswami, Rick Mukherjee, Peter Schmelcher

quant-phphysics.comp-phSubmitted Sep 19, 2026• Announced Sep 22, 2026• 0 citations
arXivHTMLPDF

Abstract

Recently, a hybrid qudit-qubit algorithm [1] was presented for solving the integer programming problem with a polynomial quantum advantage. In this work, we investigate the algorithm [1] to understand the role of qudits ($d$-dimensional quantum system) by conducting a comparative resource analysis with its qubit-only implementation and the classical simulability of the algorithm by exploring the entanglement structure. The resource analysis part is performed in terms of logical gate counts, and fault-tolerant physical resources, including non-Clifford gates. The hybrid qudit-qubit implementation has a more compact structure of the unitary operators as opposed to its qubit-only simulation which reduces the logical and fault-tolerant resource requirements. Two example problems, one with qutrits ($d=3$) and the other with ququint ($d=5$), when contrasted with their qubit-only implementation, within a simplified fault-tolerant resource model, showed $\sim 180 \times $ and $\sim 2220\times$ fewer total resource count, respectively. For the entanglement study, volume-law-like entropy growth and signatures of multi-partite entanglement is observed leading to increasing difficulty in the classical simulation of the algorithm. The algorithm generates synergistic tri-partite entanglement even for a quadratic problem, revealing that the algorithmic structure itself can generate higher-order entanglement in the system independent of the problem.

Comments
22 pages, 6 figures, 3 tables

Related papers

Qudit-based scalable quantum algorithm for solving the integer programming problem

Kapil Goswami, Peter Schmelcher, Rick Mukherjee

Integer programming (IP) is an NP-hard combinatorial optimization problem that is widely used to represent a diverse set of real-world problems spanning multiple fields, such as finance, engineering, logistics, and operations research. It is a hard problem to solve using classical algorithms, as its complexity increases with problem size. Most quantum algorithms for solving IP are highly resource-inefficient because they encode integers into qubits. In [1], the issue of resource inefficiency was addressed by mapping integer variables to qudits. However, [1] has limited practical value due to a lack of scalability to multiple qudits to encode larger problems. In this work, by extending upon the ideas of [1], a circuit-based scalable quantum algorithm is presented using multiple interacting qudits for which we show a quantum speed-up for solving the integer programming problem. The quantum algorithm consists of a distillation function that efficiently separates the feasible from the infeasible regions, a phase-amplitude encoding for the cost function, and a quantum phase estimation coupled with a multi-controlled single-qubit rotation for optimization. We prove that our algorithm yields the optimal solution with the maximum measurement probability. The time complexity for the quantum algorithm is shown to be $O(r_P(mn^2log d + d^{n/2}/N_{y_s}^{1/2} + n ε_{\text{QPE}}^{-1}))$ for a problem with the number of variables $n$ taking $d$ integer values, satisfying $m$ constraints with a precision of $ε_{\text{QPE}}$ and $r_P$ repetitions required for reaching a success probability $P$. Compared to the classical time complexity of brute force $O(d^n)$ and the classical exact algorithm $O((\log{n})^{O(n)})$, it incurs a reduction of $\sim d^{n/2}$ in the time complexity (for a polynomial number of repetitions and precision requirements) for solving a general polynomial IP problem.

arXiv:2508.13906•Aug 19, 2025•0 citations

Fault-Tolerant Resource Comparison of Qudit and Qubit Encodings for Diagonal Quadratic Operators

Samuel Godwood, Doğa Murat Kürkçüoğlu, Gabriel N. Perdue +2 more

Finite local Hilbert-space truncations arise naturally in quantum simulations of lattice field theories and motivate qudit encodings, but their fault-tolerant advantage over qubit encodings remains unclear. We compare the non-Clifford cost of implementing quadratic diagonal evolutions, exemplified by $U=e^{-itφ_x^2}$ in a uniform field-amplitude discretization of a real scalar field, using either one logical $d$-level qudit or $n_b=\lceil \log_2 d\rceil$ logical qubits. We analyze two standard settings: product-formula simulation and LCU/block encoding, taking the resource metric to be the number of non-Clifford gates after synthesis into a discrete logical gate set. Because tight synthesis bounds for general single-qudit rotations are not known, we express the qudit constructions in terms of embedded two-level $SU(2)$ rotations and derive explicit finite-$d$ break-even conditions for their synthesis cost; these serve as compiler targets for when qudit encodings can outperform the qubit baseline. Within the constructive models studied here, product-formula implementations would require an exponentially stronger per-primitive synthesis advantage for qudits to win asymptotically, while in the LCU setting the qubit encoding is asymptotically cheaper in $d$. Nevertheless, the finite-$d$ threshold analysis identifies low dimensional regions in which qudits can yield meaningful constant-factor savings, particularly for LCU-based implementations. As a secondary analysis of the LCU construction, we use an idealized negligible-overhead qubit-qudit code-switching model to give an absolute $T$-count comparison, and reinterpret the savings as an allowable per-switch overhead budget.

quant-pharXiv:2604.26792•Physical Review A•Apr 30, 2026•0 citations

QuDiet: A classical simulation platform for qubit‐qudit hybrid quantum systems

Turbasu Chatterjee, Arnav Das, Subhayu Kumar Bala +3 more

Abstract In recent years, numerous research advancements have extended the limit of classical simulation of quantum algorithms. Although, most of the state‐of‐the‐art classical simulators are only limited to binary quantum systems, which restrict the classical simulation of higher‐dimensional quantum computing systems. Through recent developments in higher‐dimensional quantum computing systems, it is realised that implementing qudits improves the overall performance of a quantum algorithm by increasing memory space and reducing the asymptotic complexity of a quantum circuit. Hence, in this article, QuDiet , a state‐of‐the‐art user‐friendly python‐based higher‐dimensional quantum computing simulator is introduced. QuDiet offers multi‐valued logic operations by utilising generalised quantum gates with an abstraction so that any naive user can simulate qudit systems with ease as compared to the existing ones. Various benchmark quantum circuits is simulated in QuDiet and show the considerable speedup in simulation time as compared to the other simulators without loss in precision. Finally, QuDiet provides a full qubit‐qudit hybrid quantum simulator package with quantum circuit templates of well‐known quantum algorithms for fast prototyping and simulation. Comprehensive simulation up to 20 qutrits circuit on depth 80 on QuDiet was successfully achieved. The complete code and packages of QuDiet is available at https://github.com/LegacYFTw/QuDiet .

arXiv:2211.07918•IET Quantum Communication•Mar 28, 2023•13 citations

Study of Quantum Entanglement and Its Applications in Quantum Computing

Shanu Yadav

One of the key non-classical resources involved in the promise of quantum computing is quantum entanglement. It allows for correlations between qubits that are not possible by independent local states, thus it can be used for computational speed-up, quantum simulation, quantum error correction, quantum machine learning, and secure quantum communication. This paper explores the role of entanglement in quantum computing, and looks at its applications with a secondary-data based research design. This study will evaluate the progress of entanglement from a fundamental physical phenomenon to an engineering resource for processors, algorithms, and fault-tolerant architectures from peer-reviewed literature, institutional reports and public research data from 2018 to 2025. The paper is divided into five subheadings in the introduction, four subheadings in the literature review, a research methodology, and a results section with five secondary-data tables, and a conclusion. The findings reveal a significant acceleration in noisy intermediate-scale quantum devices between 2018 and 2025, along with efforts to prove quantum computational advantage, grow of variational algorithms and increased advancement toward logical qubits and quantum error correction. The evidence also shows that there are important limitations for practical quantum benefit, including decoherence, errors in quantum gates, difficulties loading data, benchmarking arguments, and the high cost of overhead error correction in fault-tolerant quantum computing. The authors conclude that entanglement is not just a theoretical property of quantum physics, but the resource that is needed to link hardware and software with applications. In the future, fidelity of entangling gates, scalable qubit connectivity, error-mitigated algorithms, and fault-tolerant logical qubit designs will all be important.

International journal of engineering science & humanities.•Jul 12, 2026•0 citations

Fault-Tolerant Encoding of Logical Qudits in Spin Systems

Sumin Lim

Universal quantum computers require fault-tolerant logical qudits, as qudits naturally align with the simulation of multi-level physical systems. Here, we present a general framework and working examples for encoding fault-tolerant logical qudits in finite-dimensional spin systems. We construct distance-$3$, distance-$5$ codewords, and general $2t+1$-distance codes that can be implemented using a single physical qudit or a small number of coupled qudits for higher distances, while requiring a Hilbert space dimension significantly smaller than conventional constructions based on multiple logical qubits. Logical operations and error correction protocols can be implemented with polynomial scaling in the number of elementary operations. We further discuss schematic designs for physical implementation and required single-gate fidelities, which are compatible with current spin qudit platforms. This strategy provides a resource-efficient path toward realizing fault-tolerant logical qudits in finite multi-level physical systems.

quant-pharXiv:2511.06620•Physical Review A•Nov 11, 2025•0 citations

Quantum-classical crossover in fault-tolerant quantum dynamics simulation

Jinzhao Sun, Bozhen Zhou, Jue Xu +28 more

While quantum computers promise to solve classically intractable problems, identifying the point at which fault-tolerant quantum computation outperforms the best classical algorithms for practical applications remains an outstanding challenge. Here we establish a concrete quantum-classical crossover for quantum many-body dynamics under realistic hardware conditions. We introduce a scalable fault-tolerant framework that combines coherent observable estimation with a space-time-efficient implementation of non-Clifford rotations, suppressing the residual logical errors that limit existing partially fault-tolerant approaches. A benchmark against state-of-the-art tensor-network and variational Monte Carlo algorithms reveals a concrete crossover for mixed-field Ising dynamics at modest system sizes. For a physical error rate of $p=10^{-3}$, fault-tolerant simulation requires approximately 2 hours and $3.7 \times 10^5$ physical qubits for a 100-site 1D system, whereas tensor network approaches would require about 100 years. For 2D models, where rapid entanglement growth limits the classical evolution time, we project quantum runtimes within minutes. A physical error rate of $p=10^{-4}$ leads to at least an order of magnitude reduction in qubit count ($3.1 \times 10^4$ physical qubits) and runtime (minutes for 1D and seconds for 2D). The reduction in quantum runtime arises from our improved rotation-state injection and co-design of quantum error correction and observable-estimation protocols, which jointly suppress logical-error accumulation and reduce sampling overhead. Our results establish a scalable route towards practical quantum advantage and identify quantitative engineering targets for future fault-tolerant architectures.

quant-pharXiv:2607.16116•Jul 20, 2026•0 citations
Recently, a hybrid qudit-qubit algorithm [1] was presented for solving the integer programming problem with a polynomial quantum advantage. In this work, we investigate the algorithm [1] to understand the role of qudits (ddd-dimensional quantum system) by conducting a comparative resource analysis with its qubit-only implementation and the classical simulability of the algorithm by exploring the entanglement structure. The resource analysis part is performed in terms of logical gate counts, and fault-tolerant physical resources, including non-Clifford gates. The hybrid qudit-qubit implementation has a more compact structure of the unitary operators as opposed to its qubit-only simulation which reduces the logical and fault-tolerant resource requirements. Two example problems, one with qutrits (d=3d=3d=3) and the other with ququint (d=5d=5d=5), when contrasted with their qubit-only implementation, within a simplified fault-tolerant resource model, showed ∼180×\sim 180 \times ∼180× and ∼2220×\sim 2220\times∼2220× fewer total resource count, respectively. For the entanglement study, volume-law-like entropy growth and signatures of multi-partite entanglement is observed leading to increasing difficulty in the classical simulation of the algorithm. The algorithm generates synergistic tri-partite entanglement even for a quadratic problem, revealing that the algorithmic structure itself can generate higher-order entanglement in the system independent of the problem.
Integer programming (IP) is an NP-hard combinatorial optimization problem that is widely used to represent a diverse set of real-world problems spanning multiple fields, such as finance, engineering, logistics, and operations research. It is a hard problem to solve using classical algorithms, as its complexity increases with problem size. Most quantum algorithms for solving IP are highly resource-inefficient because they encode integers into qubits. In [1], the issue of resource inefficiency was addressed by mapping integer variables to qudits. However, [1] has limited practical value due to a lack of scalability to multiple qudits to encode larger problems. In this work, by extending upon the ideas of [1], a circuit-based scalable quantum algorithm is presented using multiple interacting qudits for which we show a quantum speed-up for solving the integer programming problem. The quantum algorithm consists of a distillation function that efficiently separates the feasible from the infeasible regions, a phase-amplitude encoding for the cost function, and a quantum phase estimation coupled with a multi-controlled single-qubit rotation for optimization. We prove that our algorithm yields the optimal solution with the maximum measurement probability. The time complexity for the quantum algorithm is shown to be O(rP(mn2logd+dn/2/Nys1/2+nεQPE−1))O(r_P(mn^2log d + d^{n/2}/N_{y_s}^{1/2} + n ε_{\text{QPE}}^{-1}))O(rP​(mn2logd+dn/2/Nys​1/2​+nεQPE−1​)) for a problem with the number of variables nnn taking ddd integer values, satisfying mmm constraints with a precision of εQPEε_{\text{QPE}}εQPE​ and rPr_PrP​ repetitions required for reaching a success probability PPP. Compared to the classical time complexity of brute force O(dn)O(d^n)O(dn) and the classical exact algorithm O((log⁡n)O(n))O((\log{n})^{O(n)})O((logn)O(n)), it incurs a reduction of ∼dn/2\sim d^{n/2}∼dn/2 in the time complexity (for a polynomial number of repetitions and precision requirements) for solving a general polynomial IP problem.
Finite local Hilbert-space truncations arise naturally in quantum simulations of lattice field theories and motivate qudit encodings, but their fault-tolerant advantage over qubit encodings remains unclear. We compare the non-Clifford cost of implementing quadratic diagonal evolutions, exemplified by U=e−itφx2U=e^{-itφ_x^2}U=e−itφx2​ in a uniform field-amplitude discretization of a real scalar field, using either one logical ddd-level qudit or nb=⌈log⁡2d⌉n_b=\lceil \log_2 d\rceilnb​=⌈log2​d⌉ logical qubits. We analyze two standard settings: product-formula simulation and LCU/block encoding, taking the resource metric to be the number of non-Clifford gates after synthesis into a discrete logical gate set. Because tight synthesis bounds for general single-qudit rotations are not known, we express the qudit constructions in terms of embedded two-level SU(2)SU(2)SU(2) rotations and derive explicit finite-ddd break-even conditions for their synthesis cost; these serve as compiler targets for when qudit encodings can outperform the qubit baseline. Within the constructive models studied here, product-formula implementations would require an exponentially stronger per-primitive synthesis advantage for qudits to win asymptotically, while in the LCU setting the qubit encoding is asymptotically cheaper in ddd. Nevertheless, the finite-ddd threshold analysis identifies low dimensional regions in which qudits can yield meaningful constant-factor savings, particularly for LCU-based implementations. As a secondary analysis of the LCU construction, we use an idealized negligible-overhead qubit-qudit code-switching model to give an absolute TTT-count comparison, and reinterpret the savings as an allowable per-switch overhead budget.
Abstract In recent years, numerous research advancements have extended the limit of classical simulation of quantum algorithms. Although, most of the state‐of‐the‐art classical simulators are only limited to binary quantum systems, which restrict the classical simulation of higher‐dimensional quantum computing systems. Through recent developments in higher‐dimensional quantum computing systems, it is realised that implementing qudits improves the overall performance of a quantum algorithm by increasing memory space and reducing the asymptotic complexity of a quantum circuit. Hence, in this article, QuDiet , a state‐of‐the‐art user‐friendly python‐based higher‐dimensional quantum computing simulator is introduced. QuDiet offers multi‐valued logic operations by utilising generalised quantum gates with an abstraction so that any naive user can simulate qudit systems with ease as compared to the existing ones. Various benchmark quantum circuits is simulated in QuDiet and show the considerable speedup in simulation time as compared to the other simulators without loss in precision. Finally, QuDiet provides a full qubit‐qudit hybrid quantum simulator package with quantum circuit templates of well‐known quantum algorithms for fast prototyping and simulation. Comprehensive simulation up to 20 qutrits circuit on depth 80 on QuDiet was successfully achieved. The complete code and packages of QuDiet is available at https://github.com/LegacYFTw/QuDiet .
One of the key non-classical resources involved in the promise of quantum computing is quantum entanglement. It allows for correlations between qubits that are not possible by independent local states, thus it can be used for computational speed-up, quantum simulation, quantum error correction, quantum machine learning, and secure quantum communication. This paper explores the role of entanglement in quantum computing, and looks at its applications with a secondary-data based research design. This study will evaluate the progress of entanglement from a fundamental physical phenomenon to an engineering resource for processors, algorithms, and fault-tolerant architectures from peer-reviewed literature, institutional reports and public research data from 2018 to 2025. The paper is divided into five subheadings in the introduction, four subheadings in the literature review, a research methodology, and a results section with five secondary-data tables, and a conclusion. The findings reveal a significant acceleration in noisy intermediate-scale quantum devices between 2018 and 2025, along with efforts to prove quantum computational advantage, grow of variational algorithms and increased advancement toward logical qubits and quantum error correction. The evidence also shows that there are important limitations for practical quantum benefit, including decoherence, errors in quantum gates, difficulties loading data, benchmarking arguments, and the high cost of overhead error correction in fault-tolerant quantum computing. The authors conclude that entanglement is not just a theoretical property of quantum physics, but the resource that is needed to link hardware and software with applications. In the future, fidelity of entangling gates, scalable qubit connectivity, error-mitigated algorithms, and fault-tolerant logical qubit designs will all be important.
Universal quantum computers require fault-tolerant logical qudits, as qudits naturally align with the simulation of multi-level physical systems. Here, we present a general framework and working examples for encoding fault-tolerant logical qudits in finite-dimensional spin systems. We construct distance-333, distance-555 codewords, and general 2t+12t+12t+1-distance codes that can be implemented using a single physical qudit or a small number of coupled qudits for higher distances, while requiring a Hilbert space dimension significantly smaller than conventional constructions based on multiple logical qubits. Logical operations and error correction protocols can be implemented with polynomial scaling in the number of elementary operations. We further discuss schematic designs for physical implementation and required single-gate fidelities, which are compatible with current spin qudit platforms. This strategy provides a resource-efficient path toward realizing fault-tolerant logical qudits in finite multi-level physical systems.
While quantum computers promise to solve classically intractable problems, identifying the point at which fault-tolerant quantum computation outperforms the best classical algorithms for practical applications remains an outstanding challenge. Here we establish a concrete quantum-classical crossover for quantum many-body dynamics under realistic hardware conditions. We introduce a scalable fault-tolerant framework that combines coherent observable estimation with a space-time-efficient implementation of non-Clifford rotations, suppressing the residual logical errors that limit existing partially fault-tolerant approaches. A benchmark against state-of-the-art tensor-network and variational Monte Carlo algorithms reveals a concrete crossover for mixed-field Ising dynamics at modest system sizes. For a physical error rate of p=10−3p=10^{-3}p=10−3, fault-tolerant simulation requires approximately 2 hours and 3.7×1053.7 \times 10^53.7×105 physical qubits for a 100-site 1D system, whereas tensor network approaches would require about 100 years. For 2D models, where rapid entanglement growth limits the classical evolution time, we project quantum runtimes within minutes. A physical error rate of p=10−4p=10^{-4}p=10−4 leads to at least an order of magnitude reduction in qubit count (3.1×1043.1 \times 10^43.1×104 physical qubits) and runtime (minutes for 1D and seconds for 2D). The reduction in quantum runtime arises from our improved rotation-state injection and co-design of quantum error correction and observable-estimation protocols, which jointly suppress logical-error accumulation and reduce sampling overhead. Our results establish a scalable route towards practical quantum advantage and identify quantitative engineering targets for future fault-tolerant architectures.