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

Topological obstructions to implementing controlled unknown unitaries

Zuzana Gavorová, Matan Seidel, Yonathan Touati

Published Nov 19, 2020• 8 citations
OpenAlex

Abstract

Is a quantum algorithm capable of implementing an if-clause? Given a black-box subroutine, a $d$-dimensional unitary $U\in U(d)$, a quantum if-clause would correspond to applying it to an input qudit if and only if the value of a control qubit is $1$. It was previously shown by Thompson et al. and Araujo et al. that implementations using single access to the oracle $U$ are impossible. Our main result is a strong generalization of this impossibility result: we prove that there is no unitary oracle algorithm implementing $control_\phi(U)=\left|0\right>\!\!\left \!\!\left<1\right|\otimes U$, for some $U$-dependent phase $\phi(U)$, even if allowed any finite number of calls to $U$ and $U^\dagger$, and even if required to only approximate the desired operator $control_\phi(U)$. Even further, there is no such \emph{postselection} oracle algorithm, i.e. a unitary oracle algorithm followed by a binary success/fail measurement, that reports success and implements $control_\phi(U)$ with a nonzero probability for each $U\in U(d)$. Our proof relies on topological arguments which can be viewed as a modification of the Borsuk-Ulam theorem. Combining the topological arguments with the algorithm of Dong et al. in fact leads to an interesting dichotomy: implementing $control_\phi(U^m)$ in our model is possible if and only if the integer $m$ is a multiple of the oracle's dimension $d$. Our impossibility no longer holds if the model is relaxed, either by dropping the worst-case requirement that the algorithm works for all $U\in U(d)$, or, remarkably, by allowing measurements more general than a binary postselection measurement. We observe that for both relaxations, inefficient algorithms exist, and it remains open whether efficient ones do.

Related papers

Topological obstructions to quantum computation with unitary oracles

Zuzana Gavorová, Matan Seidel, Yonathan Touati

Algorithms with unitary oracles can be nested, which makes them extremely versatile. An example is the phase estimation algorithm used in many candidate algorithms for quantum speedup. The search for new quantum algorithms benefits from understanding their limitations: Some tasks are impossible in quantum circuits, although their classical versions are easy, for example, cloning. An example with a unitary oracle U is the if clause, the task to implement controlled U (up to the phase on U ). In classical computation the conditional statement is easy and essential. In quantum circuits the if clause was shown impossible from one query to U . Is it possible from polynomially many queries? Here we unify algorithms with a unitary oracle and develop a topological method to prove their limitations: No number of queries to U and U† lets quantum circuits implement the if clause, even if admitting approximations, postselection, and relaxed causality. We also show limitations of process tomography, oracle neutralization, and UdimU, UT , and U† algorithms. Our results strengthen an advantage of linear optics, challenge the experiments on relaxed causality, and motivate new algorithms with many-outcome measurements. Published by the American Physical Society 2024

arXiv:2011.10031•Physical Review A•Mar 28, 2024•4 citations

Quantum circuits cannot control unknown operations

Mateus Araújo, Adrien Feix, Fabio Costa +1 more

One of the essential building blocks of classical computer programs is the ' if ' clause, which executes a subroutine depending on the value of a control variable. Similarly, several quantum algorithms rely on applying a unitary operation conditioned on the state of a control system. Here we show that this control cannot be performed by a quantum circuit if the unitary is completely unknown. The task remains impossible even if we allow the control to be done modulo a global phase. However, this no-go theorem does not prevent implementing quantum control of unknown unitaries in practice, as any physical implementation of an unknown unitary provides additional information that makes the control possible. We then argue that one should extend the quantum circuit formalism to capture this possibility in a straightforward way. This is done by allowing unknown unitaries to be applied to subspaces and not only to subsystems.

arXiv:1309.7976•New Journal of Physics•Sep 22, 2014•119 citations

Possible Implementations of Oracles in Quantum Algorithms

Jiahao Zhao

Abstract Quantum computing is an inspiring technic on solving complicate problems, which shows the superiority over the classical computing. Contemporarily, the quantum-based algorithms were invented in many purposes on solving those problems. The thing is some of the algorithms were composed with oracles, which can be treated as a black box. It can be worked out/analyzed in theoretical mathematical expressions, but it can never fall in the ground without those actual implementations. Therefore, this paper will illustrate the idea and possible implementations on some quantum algorithm. Among various algorithms, this research will choose those relatively famous quantum algorithms, i.e., Deutsch-Jozsa Algorithm, Shor’s Algorithm, and Grover’s Algorithm. Different algorithms have the different intrinsic logics, which means there is no general description for all solution in this problem, but all of those can achieve the goal according to the same framework. Since those oracles are black boxes that can only be analyzed by its behavior with different cases, and then based on the behaviors and cases, and in IBM quantum platform, one can fill out the oracle by manipulate with different quantum operators. Lastly, the figures of some the possible implementation of those oracles with the three quantum algorithms will be shown in the IBM quantum platform, as well as the histograms of probability distributions that can justify the correctness of the implementations. These results shed light on guiding further exploration of the design and analysis on quantum algorithms.

Journal of Physics Conference Series•Dec 1, 2022•1 citation

A One-Query Lower Bound for Unitary Synthesis and Breaking Quantum Cryptography

Alex Lombardi, Fermi Ma, John Wright

The Unitary Synthesis Problem (Aaronson-Kuperberg 2007) asks whether any n-qubit unitary U can be implemented by an efficient quantum algorithm A augmented with an oracle that computes an arbitrary Boolean function f. In other words, can the task of implementing any unitary be efficiently reduced to the task of implementing any Boolean function? In this work, we prove a one-query lower bound for unitary synthesis. We show that there exist unitaries U such that no quantum polynomial-time oracle algorithm Af can implement U, even approximately, if it only makes one (quantum) query to f. Our approach also has implications for quantum cryptography: we prove (relative to a random oracle) the existence of quantum cryptographic primitives that remain secure against all one-query adversaries Af. Since such one-query algorithms can decide any language, solve any classical search problem, and even prepare any quantum state, our result suggests that implementing random unitaries and breaking quantum cryptography may be harder than all of these tasks. To prove this result, we formulate unitary synthesis as an efficient challenger-adversary game, which enables proving lower bounds by analyzing the maximum success probability of an adversary Af. Our main technical insight is to identify a natural spectral relaxation of the one-query optimization problem, which we bound using tools from random matrix theory. We view our framework as a potential avenue to rule out polynomial-query unitary synthesis, and we state conjectures in this direction.

arXiv:2310.08870•ACM Symposium on Theory of Computing (STOC)•Jun 10, 2024•16 citations

Uncomputability and complexity of quantum control

Denys I. Bondar, Alexander Nikolaevich Pechen

In laboratory and numerical experiments, physical quantities are known with a finite precision and described by rational numbers. Based on this, we deduce that quantum control problems both for open and closed systems are in general not algorithmically solvable, i.e., there is no algorithm that can decide whether dynamics of an arbitrary quantum system can be manipulated by accessible external interactions (coherent or dissipative) such that a chosen target reaches a desired value. This conclusion holds even for the relaxed requirement of the target only approximately attaining the desired value. These findings do not preclude an algorithmic solvability for a particular class of quantum control problems. Moreover, any quantum control problem can be made algorithmically solvable if the set of accessible interactions (i.e., controls) is rich enough. To arrive at these results, we develop a technique based on establishing the equivalence between quantum control problems and Diophantine equations, which are polynomial equations with integer coefficients and integer unknowns. In addition to proving uncomputability, this technique allows to construct quantum control problems belonging to different complexity classes. In particular, an example of the control problem involving a two-mode coherent field is shown to be NP-hard, contradicting a widely held believe that two-body problems are easy.

arXiv:1907.10082•Scientific Reports•Jan 27, 2020•18 citations

Quantum Query Complexity of Unitary Operator Discrimination

Akinori Kawachi, Kenichi Kawano, François Le Gall +1 more

Unitary operator discrimination is a fundamental problem in quantum information theory. The basic version of this problem can be described as follows: Given a black box implementing a unitary operator U∈S:={U1, U2} under some probability distribution over S, the goal is to decide whether U=U1 or U=U2. In this paper, we consider the query complexity of this problem. We show that there exists a quantum algorithm that solves this problem with bounded error probability using $\lceil{\sqrt{6}\theta_{\rm cover}^{-1}}\rceil$ queries to the black box in the worst case, i.e., under any probability distribution over S, where the parameter θcover, which is determined by the eigenvalues of $U_1^\dagger {U_2}$, represents the “closeness” between U1 and U2. We also show that this upper bound is essentially tight: we prove that for every θcover > 0 there exist operators U1 and U2 such that any quantum algorithm solving this problem with bounded error probability requires at least $\lceil{\frac{2}{3 \theta_{\rm cover}}}\rceil$ queries under uniform distribution over S.

IEICE Transactions on Information and Systems•Feb 28, 2019•3 citations
Is a quantum algorithm capable of implementing an if-clause? Given a black-box subroutine, a ddd-dimensional unitary U∈U(d)U\in U(d)U∈U(d), a quantum if-clause would correspond to applying it to an input qudit if and only if the value of a control qubit is 111. It was previously shown by Thompson et al. and Araujo et al. that implementations using single access to the oracle UUU are impossible. Our main result is a strong generalization of this impossibility result: we prove that there is no unitary oracle algorithm implementing control_\phi(U)=\left|0\right>\!\!\left \!\!\left<1\right|\otimes U, for some UUU-dependent phase ϕ(U)\phi(U)ϕ(U), even if allowed any finite number of calls to UUU and U†U^\daggerU†, and even if required to only approximate the desired operator controlϕ(U)control_\phi(U)controlϕ​(U). Even further, there is no such \emph{postselection} oracle algorithm, i.e. a unitary oracle algorithm followed by a binary success/fail measurement, that reports success and implements controlϕ(U)control_\phi(U)controlϕ​(U) with a nonzero probability for each U∈U(d)U\in U(d)U∈U(d).
Our proof relies on topological arguments which can be viewed as a modification of the Borsuk-Ulam theorem. Combining the topological arguments with the algorithm of Dong et al. in fact leads to an interesting dichotomy: implementing controlϕ(Um)control_\phi(U^m)controlϕ​(Um) in our model is possible if and only if the integer mmm is a multiple of the oracle's dimension ddd.
Our impossibility no longer holds if the model is relaxed, either by dropping the worst-case requirement that the algorithm works for all U∈U(d)U\in U(d)U∈U(d), or, remarkably, by allowing measurements more general than a binary postselection measurement. We observe that for both relaxations, inefficient algorithms exist, and it remains open whether efficient ones do.
Algorithms with unitary oracles can be nested, which makes them extremely versatile. An example is the phase estimation algorithm used in many candidate algorithms for quantum speedup. The search for new quantum algorithms benefits from understanding their limitations: Some tasks are impossible in quantum circuits, although their classical versions are easy, for example, cloning. An example with a unitary oracle U is the if clause, the task to implement controlled U (up to the phase on U ). In classical computation the conditional statement is easy and essential. In quantum circuits the if clause was shown impossible from one query to U . Is it possible from polynomially many queries? Here we unify algorithms with a unitary oracle and develop a topological method to prove their limitations: No number of queries to U and U† lets quantum circuits implement the if clause, even if admitting approximations, postselection, and relaxed causality. We also show limitations of process tomography, oracle neutralization, and UdimU, UT , and U† algorithms. Our results strengthen an advantage of linear optics, challenge the experiments on relaxed causality, and motivate new algorithms with many-outcome measurements. Published by the American Physical Society 2024
One of the essential building blocks of classical computer programs is the ' if ' clause, which executes a subroutine depending on the value of a control variable. Similarly, several quantum algorithms rely on applying a unitary operation conditioned on the state of a control system. Here we show that this control cannot be performed by a quantum circuit if the unitary is completely unknown. The task remains impossible even if we allow the control to be done modulo a global phase. However, this no-go theorem does not prevent implementing quantum control of unknown unitaries in practice, as any physical implementation of an unknown unitary provides additional information that makes the control possible. We then argue that one should extend the quantum circuit formalism to capture this possibility in a straightforward way. This is done by allowing unknown unitaries to be applied to subspaces and not only to subsystems.
Abstract Quantum computing is an inspiring technic on solving complicate problems, which shows the superiority over the classical computing. Contemporarily, the quantum-based algorithms were invented in many purposes on solving those problems. The thing is some of the algorithms were composed with oracles, which can be treated as a black box. It can be worked out/analyzed in theoretical mathematical expressions, but it can never fall in the ground without those actual implementations. Therefore, this paper will illustrate the idea and possible implementations on some quantum algorithm. Among various algorithms, this research will choose those relatively famous quantum algorithms, i.e., Deutsch-Jozsa Algorithm, Shor’s Algorithm, and Grover’s Algorithm. Different algorithms have the different intrinsic logics, which means there is no general description for all solution in this problem, but all of those can achieve the goal according to the same framework. Since those oracles are black boxes that can only be analyzed by its behavior with different cases, and then based on the behaviors and cases, and in IBM quantum platform, one can fill out the oracle by manipulate with different quantum operators. Lastly, the figures of some the possible implementation of those oracles with the three quantum algorithms will be shown in the IBM quantum platform, as well as the histograms of probability distributions that can justify the correctness of the implementations. These results shed light on guiding further exploration of the design and analysis on quantum algorithms.
The Unitary Synthesis Problem (Aaronson-Kuperberg 2007) asks whether any n-qubit unitary U can be implemented by an efficient quantum algorithm A augmented with an oracle that computes an arbitrary Boolean function f. In other words, can the task of implementing any unitary be efficiently reduced to the task of implementing any Boolean function? In this work, we prove a one-query lower bound for unitary synthesis. We show that there exist unitaries U such that no quantum polynomial-time oracle algorithm Af can implement U, even approximately, if it only makes one (quantum) query to f. Our approach also has implications for quantum cryptography: we prove (relative to a random oracle) the existence of quantum cryptographic primitives that remain secure against all one-query adversaries Af. Since such one-query algorithms can decide any language, solve any classical search problem, and even prepare any quantum state, our result suggests that implementing random unitaries and breaking quantum cryptography may be harder than all of these tasks. To prove this result, we formulate unitary synthesis as an efficient challenger-adversary game, which enables proving lower bounds by analyzing the maximum success probability of an adversary Af. Our main technical insight is to identify a natural spectral relaxation of the one-query optimization problem, which we bound using tools from random matrix theory. We view our framework as a potential avenue to rule out polynomial-query unitary synthesis, and we state conjectures in this direction.
In laboratory and numerical experiments, physical quantities are known with a finite precision and described by rational numbers. Based on this, we deduce that quantum control problems both for open and closed systems are in general not algorithmically solvable, i.e., there is no algorithm that can decide whether dynamics of an arbitrary quantum system can be manipulated by accessible external interactions (coherent or dissipative) such that a chosen target reaches a desired value. This conclusion holds even for the relaxed requirement of the target only approximately attaining the desired value. These findings do not preclude an algorithmic solvability for a particular class of quantum control problems. Moreover, any quantum control problem can be made algorithmically solvable if the set of accessible interactions (i.e., controls) is rich enough. To arrive at these results, we develop a technique based on establishing the equivalence between quantum control problems and Diophantine equations, which are polynomial equations with integer coefficients and integer unknowns. In addition to proving uncomputability, this technique allows to construct quantum control problems belonging to different complexity classes. In particular, an example of the control problem involving a two-mode coherent field is shown to be NP-hard, contradicting a widely held believe that two-body problems are easy.
Unitary operator discrimination is a fundamental problem in quantum information theory. The basic version of this problem can be described as follows: Given a black box implementing a unitary operator U∈S:={U1, U2} under some probability distribution over S, the goal is to decide whether U=U1 or U=U2. In this paper, we consider the query complexity of this problem. We show that there exists a quantum algorithm that solves this problem with bounded error probability using ⌈6θcover−1⌉\lceil{\sqrt{6}\theta_{\rm cover}^{-1}}\rceil⌈6​θcover−1​⌉ queries to the black box in the worst case, i.e., under any probability distribution over S, where the parameter θcover, which is determined by the eigenvalues of U1†U2U_1^\dagger {U_2}U1†​U2​, represents the “closeness” between U1 and U2. We also show that this upper bound is essentially tight: we prove that for every θcover > 0 there exist operators U1 and U2 such that any quantum algorithm solving this problem with bounded error probability requires at least ⌈23θcover⌉\lceil{\frac{2}{3 \theta_{\rm cover}}}\rceil⌈3θcover​2​⌉ queries under uniform distribution over S.