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

Alternative models for quantum computation

Cedric Yen-Yu Lin

Published Jan 1, 2015• 0 citations
OpenAlex

Abstract

We propose and study two new computational models for quantum computation, and infer new insights about the circumstances that give quantum computers an advantage over classical ones. The bomb query complexity model is a variation on the query complexity model, inspired by the Elitzur-Vaidman bomb tester. In this model after each query to the black box the result is measured, and the algorithm fails if the measurement gives a 1. We show that the bomb query complexity is asymptotically the square of the usual quantum query complexity. We then show a general method of converting certain classical algorithms to bomb query algorithms, which then give improved quantum algorithms. We apply this general method to graph problems, giving improved quantum query algorithms for single-source shortest paths and maximum bipartite matching. Normalizer circuits are a class of restricted quantum circuits defined on Hilbert spaces associated with Abelian groups. These circuits generalize the Clifford group, and are composed of gates implementing quantum Fourier transforms, automorphisms, and quadratic phases. We show that these circuits can be simulated efficiently on a classical computer even on infinite Abelian groups (the finite case is known [1, 21), as long as the group is decomposed into primitive subgroups. This result gives a generalization of the Gottesman-Knill theorem to infinite groups. However, if the underlying group is not decomposed (the group is a black box group) then normalizer circuits include many well known quantum algorithms, including Shor's factoring algorithm. There is therefore a large difference in computational power between normalizer circuits over explicitly decomposed versus black box groups. In fact, we show that a version of the problem of decomposing Abelian groups is complete for the complexity class associated with normalizer circuits over black box groups: any such normalizer circuit can be simulated classically given the ability to decompose Abelian groups.

Related papers

The computational power of normalizer circuits over black-box groups

Juan Bermejo-Vega, Cedric Yen-Yu Lin, Maarten Van den Nest

This work presents a precise connection between Clifford circuits, Shor's factoring algorithm and several other famous quantum algorithms with exponential quantum speed-ups for solving Abelian hidden subgroup problems. We show that all these different forms of quantum computation belong to a common new restricted model of quantum operations that we call \emph{black-box normalizer circuits}. To define these, we extend the previous model of normalizer circuits [arXiv:1201.4867v1,arXiv:1210.3637,arXiv:1409.3208], which are built of quantum Fourier transforms, group automorphism and quadratic phase gates associated to an Abelian group $G$. In previous works, the group $G$ is always given in an explicitly decomposed form. In our model, we remove this assumption and allow $G$ to be a black-box group. While standard normalizer circuits were shown to be efficiently classically simulable [arXiv:1201.4867v1,arXiv:1210.3637,arXiv:1409.3208], we find that normalizer circuits are powerful enough to factorize and solve classically-hard problems in the black-box setting. We further set upper limits to their computational power by showing that decomposing finite Abelian groups is complete for the associated complexity class. In particular, solving this problem renders black-box normalizer circuits efficiently classically simulable by exploiting the generalized stabilizer formalism in [arXiv:1201.4867v1,arXiv:1210.3637,arXiv:1409.3208]. Lastly, we employ our connection to draw a few practical implications for quantum algorithm design: namely, we give a no-go theorem for finding new quantum algorithms with black-box normalizer circuits, a universality result for low-depth normalizer circuits, and identify two other complete problems.

arXiv:1409.4800•Sep 16, 2014•10 citations

Normalizer Circuits and Quantum Computation

Juan Bermejo-Vega

(Abridged abstract.) In this thesis we introduce new models of quantum computation to study the emergence of quantum speed-up in quantum computer algorithms. Our first contribution is a formalism of restricted quantum operations, named normalizer circuit formalism, based on algebraic extensions of the qubit Clifford gates (CNOT, Hadamard and $π/4$-phase gates): a normalizer circuit consists of quantum Fourier transforms (QFTs), automorphism gates and quadratic phase gates associated to a set $G$, which is either an abelian group or abelian hypergroup. Though Clifford circuits are efficiently classically simulable, we show that normalizer circuit models encompass Shor's celebrated factoring algorithm and the quantum algorithms for abelian Hidden Subgroup Problems. We develop classical-simulation techniques to characterize under which scenarios normalizer circuits provide quantum speed-ups. Finally, we devise new quantum algorithms for finding hidden hyperstructures. The results offer new insights into the source of quantum speed-ups for several algebraic problems. Our second contribution is an algebraic (group- and hypergroup-theoretic) framework for describing quantum many-body states and classically simulating quantum circuits. Our framework extends Gottesman's Pauli Stabilizer Formalism (PSF), wherein quantum states are written as joint eigenspaces of stabilizer groups of commuting Pauli operators: while the PSF is valid for qubit/qudit systems, our formalism can be applied to discrete- and continuous-variable systems, hybrid settings, and anyonic systems. These results enlarge the known families of quantum processes that can be efficiently classically simulated. This thesis also establishes a precise connection between Shor's quantum algorithm and the stabilizer formalism, revealing a common mathematical structure in several quantum speed-ups and error-correcting codes.

arXiv:1611.09274•Nov 28, 2016•9 citations

Upper bounds on quantum query complexity inspired by the elitzur-vaidman bomb tester

Cedric Yen-Yu Lin, Han-Hsuan Lin

Inspired by the Elitzur-Vaidman bomb testing problem [19], we introduce a new query complexity model, which we call bomb query complexity B(f). We investigate its relationship with the usual quantum query complexity Q(f), and show that B(f) = Θ(Q(f)2).This result gives a new method to upper bound the quantum query complexity: we give a method of finding bomb query algorithms from classical algorithms, which then provide nonconstructive upper bounds on [EQUATION]. We subsequently were able to give explicit quantum algorithms matching our upper bound method. We apply this method on the single-source shortest paths problem on unweighted graphs, obtaining an algorithm with O(n1.5) quantum query complexity, improving the best known algorithm of [EQUATION] [21]. Applying this method to the maximum bipartite matching problem gives an O(n1.75) algorithm, improving the best known trivial O(n2) upper bound.

•Jun 17, 2015•12 citations

Improved Quantum Algorithms for Black-Box Abelian Group Decomposition

Junrong Luo, Yinan Li, Francois Le Gall

Decomposing finite Abelian black-box groups into cyclic factors is a basic problem in quantum computation. We give a quantum algorithm for decomposing finite Abelian black-box groups by adapting the quantum sampling and classical lattice-reduction method of Regev's factoring algorithm. The algorithm computes an invariant-factor decomposition and corresponding cyclic generators with high probability. For a group G of order at most 2^n with unique encodings and reversible group-operation cost T_op = Omega(sqrt(n)), our algorithm uses O(sqrt(n)) quantum circuits, each with O~(n T_op) gates and executed at most O(n) times. For comparison, we consider the Cheung-Mosca algorithm, which decomposes the Sylow p-subgroups separately. We also consider the common-modulus implementation of the extended Cheung-Mosca algorithm. Our algorithm reduces the sum of the circuit gate counts from O~(n^2 T_op) to O~(n^(3/2) T_op). The total quantum time bound reduces from O~(n^3 T_op) to O~(n^(5/2) T_op), and the quantum space bound reduces from O(n^2) to O(n) qubits. The classical computation uses polynomially many bit operations and group-operation queries. These improvements rely on two technical ingredients. We prove that the integer relation lattices used in our algorithm admit, with high probability, integral bases whose vectors have Euclidean norm at most exp(O(sqrt(n))). We preserve the circuit-size advantage of Regev's algorithm for group decomposition by incorporating all O(n) sampled generators while keeping the lattice-reduction dimension at O(sqrt(n)).

quant-pharXiv:2609.36480•Sep 30, 2026•0 citations

Upper Bounds on Quantum Query Complexity Inspired by the Elitzur-Vaidman Bomb Tester

Cedric Yen-Yu Lin, Han-Hsuan Lin

Inspired by the Elitzur-Vaidman bomb testing problem [arXiv:hep-th/9305002], we introduce a new query complexity model, which we call bomb query complexity $B(f)$. We investigate its relationship with the usual quantum query complexity $Q(f)$, and show that $B(f)=Θ(Q(f)^2)$. This result gives a new method to upper bound the quantum query complexity: we give a method of finding bomb query algorithms from classical algorithms, which then provide nonconstructive upper bounds on $Q(f)=Θ(\sqrt{B(f)})$. We subsequently were able to give explicit quantum algorithms matching our upper bound method. We apply this method on the single-source shortest paths problem on unweighted graphs, obtaining an algorithm with $O(n^{1.5})$ quantum query complexity, improving the best known algorithm of $O(n^{1.5}\sqrt{\log n})$ [arXiv:quant-ph/0606127]. Applying this method to the maximum bipartite matching problem gives an $O(n^{1.75})$ algorithm, improving the best known trivial $O(n^2)$ upper bound.

arXiv:1410.0932•Leibniz international proceedings in informatics•Oct 3, 2014•18 citations

Topics in quantum algorithms : adiabatic algorithm, quantum money, and bomb query complexity

Han-Hsuan Lin

In this thesis, I present three results on quantum algorithms and their complexity. The first one is a numerical study on the quantum adiabatic algorithm( QAA) . We tested the performance of the QAA on random instances of MAX 2-SAT on 20 qubits and showed 3 strategics that improved QAA's performance, including a counter intuitive strategy of decreasing the overall evolution time. The second result is a security proof for the quantum money by knots proposed by Farhi et. al. We proved that quantum money by knots can not be cloned in a black box way unless graph isomorphism is efficiently solvable by a quantum computer. Lastly we defined a modified quantum query model, which we called bomb query complexity B(J), inspired by the Elitzur-Vaidman bomb-testing problem. We completely characterized bomb query complexity be showing that B(f) = [Theta](Q(f)2 ). This result implies a new method to find upper bounds on quantum query complexity, which we applied on the maximum bipartite matching problem to get an algorithm with O(n1.75) quantum query complexity, improving from the best known trivial O(n2 ) upper bound.

•Jan 1, 2015•0 citations
We propose and study two new computational models for quantum computation, and infer new insights about the circumstances that give quantum computers an advantage over classical ones. The bomb query complexity model is a variation on the query complexity model, inspired by the Elitzur-Vaidman bomb tester. In this model after each query to the black box the result is measured, and the algorithm fails if the measurement gives a 1. We show that the bomb query complexity is asymptotically the square of the usual quantum query complexity. We then show a general method of converting certain classical algorithms to bomb query algorithms, which then give improved quantum algorithms. We apply this general method to graph problems, giving improved quantum query algorithms for single-source shortest paths and maximum bipartite matching. Normalizer circuits are a class of restricted quantum circuits defined on Hilbert spaces associated with Abelian groups. These circuits generalize the Clifford group, and are composed of gates implementing quantum Fourier transforms, automorphisms, and quadratic phases. We show that these circuits can be simulated efficiently on a classical computer even on infinite Abelian groups (the finite case is known [1, 21), as long as the group is decomposed into primitive subgroups. This result gives a generalization of the Gottesman-Knill theorem to infinite groups. However, if the underlying group is not decomposed (the group is a black box group) then normalizer circuits include many well known quantum algorithms, including Shor's factoring algorithm. There is therefore a large difference in computational power between normalizer circuits over explicitly decomposed versus black box groups. In fact, we show that a version of the problem of decomposing Abelian groups is complete for the complexity class associated with normalizer circuits over black box groups: any such normalizer circuit can be simulated classically given the ability to decompose Abelian groups.
This work presents a precise connection between Clifford circuits, Shor's factoring algorithm and several other famous quantum algorithms with exponential quantum speed-ups for solving Abelian hidden subgroup problems. We show that all these different forms of quantum computation belong to a common new restricted model of quantum operations that we call \emph{black-box normalizer circuits}. To define these, we extend the previous model of normalizer circuits [arXiv:1201.4867v1,arXiv:1210.3637,arXiv:1409.3208], which are built of quantum Fourier transforms, group automorphism and quadratic phase gates associated to an Abelian group GGG. In previous works, the group GGG is always given in an explicitly decomposed form. In our model, we remove this assumption and allow GGG to be a black-box group. While standard normalizer circuits were shown to be efficiently classically simulable [arXiv:1201.4867v1,arXiv:1210.3637,arXiv:1409.3208], we find that normalizer circuits are powerful enough to factorize and solve classically-hard problems in the black-box setting. We further set upper limits to their computational power by showing that decomposing finite Abelian groups is complete for the associated complexity class. In particular, solving this problem renders black-box normalizer circuits efficiently classically simulable by exploiting the generalized stabilizer formalism in [arXiv:1201.4867v1,arXiv:1210.3637,arXiv:1409.3208]. Lastly, we employ our connection to draw a few practical implications for quantum algorithm design: namely, we give a no-go theorem for finding new quantum algorithms with black-box normalizer circuits, a universality result for low-depth normalizer circuits, and identify two other complete problems.
(Abridged abstract.) In this thesis we introduce new models of quantum computation to study the emergence of quantum speed-up in quantum computer algorithms. Our first contribution is a formalism of restricted quantum operations, named normalizer circuit formalism, based on algebraic extensions of the qubit Clifford gates (CNOT, Hadamard and π/4π/4π/4-phase gates): a normalizer circuit consists of quantum Fourier transforms (QFTs), automorphism gates and quadratic phase gates associated to a set GGG, which is either an abelian group or abelian hypergroup. Though Clifford circuits are efficiently classically simulable, we show that normalizer circuit models encompass Shor's celebrated factoring algorithm and the quantum algorithms for abelian Hidden Subgroup Problems. We develop classical-simulation techniques to characterize under which scenarios normalizer circuits provide quantum speed-ups. Finally, we devise new quantum algorithms for finding hidden hyperstructures. The results offer new insights into the source of quantum speed-ups for several algebraic problems. Our second contribution is an algebraic (group- and hypergroup-theoretic) framework for describing quantum many-body states and classically simulating quantum circuits. Our framework extends Gottesman's Pauli Stabilizer Formalism (PSF), wherein quantum states are written as joint eigenspaces of stabilizer groups of commuting Pauli operators: while the PSF is valid for qubit/qudit systems, our formalism can be applied to discrete- and continuous-variable systems, hybrid settings, and anyonic systems. These results enlarge the known families of quantum processes that can be efficiently classically simulated. This thesis also establishes a precise connection between Shor's quantum algorithm and the stabilizer formalism, revealing a common mathematical structure in several quantum speed-ups and error-correcting codes.
Inspired by the Elitzur-Vaidman bomb testing problem [19], we introduce a new query complexity model, which we call bomb query complexity B(f). We investigate its relationship with the usual quantum query complexity Q(f), and show that B(f) = Θ(Q(f)2).This result gives a new method to upper bound the quantum query complexity: we give a method of finding bomb query algorithms from classical algorithms, which then provide nonconstructive upper bounds on [EQUATION]. We subsequently were able to give explicit quantum algorithms matching our upper bound method. We apply this method on the single-source shortest paths problem on unweighted graphs, obtaining an algorithm with O(n1.5) quantum query complexity, improving the best known algorithm of [EQUATION] [21]. Applying this method to the maximum bipartite matching problem gives an O(n1.75) algorithm, improving the best known trivial O(n2) upper bound.
Decomposing finite Abelian black-box groups into cyclic factors is a basic problem in quantum computation. We give a quantum algorithm for decomposing finite Abelian black-box groups by adapting the quantum sampling and classical lattice-reduction method of Regev's factoring algorithm. The algorithm computes an invariant-factor decomposition and corresponding cyclic generators with high probability. For a group G of order at most 2^n with unique encodings and reversible group-operation cost T_op = Omega(sqrt(n)), our algorithm uses O(sqrt(n)) quantum circuits, each with O~(n T_op) gates and executed at most O(n) times. For comparison, we consider the Cheung-Mosca algorithm, which decomposes the Sylow p-subgroups separately. We also consider the common-modulus implementation of the extended Cheung-Mosca algorithm. Our algorithm reduces the sum of the circuit gate counts from O~(n^2 T_op) to O~(n^(3/2) T_op). The total quantum time bound reduces from O~(n^3 T_op) to O~(n^(5/2) T_op), and the quantum space bound reduces from O(n^2) to O(n) qubits. The classical computation uses polynomially many bit operations and group-operation queries. These improvements rely on two technical ingredients. We prove that the integer relation lattices used in our algorithm admit, with high probability, integral bases whose vectors have Euclidean norm at most exp(O(sqrt(n))). We preserve the circuit-size advantage of Regev's algorithm for group decomposition by incorporating all O(n) sampled generators while keeping the lattice-reduction dimension at O(sqrt(n)).
Inspired by the Elitzur-Vaidman bomb testing problem [arXiv:hep-th/9305002], we introduce a new query complexity model, which we call bomb query complexity B(f)B(f)B(f). We investigate its relationship with the usual quantum query complexity Q(f)Q(f)Q(f), and show that B(f)=Θ(Q(f)2)B(f)=Θ(Q(f)^2)B(f)=Θ(Q(f)2). This result gives a new method to upper bound the quantum query complexity: we give a method of finding bomb query algorithms from classical algorithms, which then provide nonconstructive upper bounds on Q(f)=Θ(B(f))Q(f)=Θ(\sqrt{B(f)})Q(f)=Θ(B(f)​). We subsequently were able to give explicit quantum algorithms matching our upper bound method. We apply this method on the single-source shortest paths problem on unweighted graphs, obtaining an algorithm with O(n1.5)O(n^{1.5})O(n1.5) quantum query complexity, improving the best known algorithm of O(n1.5log⁡n)O(n^{1.5}\sqrt{\log n})O(n1.5logn​) [arXiv:quant-ph/0606127]. Applying this method to the maximum bipartite matching problem gives an O(n1.75)O(n^{1.75})O(n1.75) algorithm, improving the best known trivial O(n2)O(n^2)O(n2) upper bound.
In this thesis, I present three results on quantum algorithms and their complexity. The first one is a numerical study on the quantum adiabatic algorithm( QAA) . We tested the performance of the QAA on random instances of MAX 2-SAT on 20 qubits and showed 3 strategics that improved QAA's performance, including a counter intuitive strategy of decreasing the overall evolution time. The second result is a security proof for the quantum money by knots proposed by Farhi et. al. We proved that quantum money by knots can not be cloned in a black box way unless graph isomorphism is efficiently solvable by a quantum computer. Lastly we defined a modified quantum query model, which we called bomb query complexity B(J), inspired by the Elitzur-Vaidman bomb-testing problem. We completely characterized bomb query complexity be showing that B(f) = [Theta](Q(f)2 ). This result implies a new method to find upper bounds on quantum query complexity, which we applied on the maximum bipartite matching problem to get an algorithm with O(n1.75) quantum query complexity, improving from the best known trivial O(n2 ) upper bound.