arXiv subjects

Richard Cleve

Publications and source records attributed to Richard Cleve.

At least 19 recordsLinked to original sources

arXiv2026

XOR Games at Full Tilt: The Hardness of Binary Nonlocal Games

It is well known that the quantum value of an XOR nonlocal game, where the winning condition depends only on the XOR of the two players' output bits, may be approximated in polynomial time. We study a variant of the XOR game model, which we call tilted XOR games, where the winning condition can additionally depend on only one of the output bits. We show that this dramatically increases the expressive power: the computational complexity of the problem of approximating the quantum value of tilted XOR games to constant precision is RE-complete. Also, our result extends to succinct versions of tilted XOR games, where the questions can be polynomial-length binary strings, generated by a polynomial-time verifier. For classical strategies, the distinction between XOR games and tilted XOR games is inconsequential. H{\aa}stad (J. ACM, 2001) shows that they are both NP-complete to approximate, by using a reduction from linear systems to XOR games. Our approach is to show that this is also quantum-sound, but as a reduction from linear system games to tilted XOR games. Since titled XOR games are a special case of binary games (where each party outputs a single bit), our result implies that binary games are RE-hard to approximate.

quant-ph↗

arXiv2026

Polynomial-Time Almost Log-Space Tree Evaluation by Catalytic Pebbling

The Tree Evaluation Problem ($\mathsf{TreeEval}$) is a computational problem originally proposed as a candidate to prove a separation between complexity classes $\mathsf{P}$ and $\mathsf{L}$. Recently, this problem has gained significant attention after Cook and Mertz (STOC 2024) showed that $\mathsf{TreeEval}$ can be solved using $O(\log n\log\log n)$ bits of space. Their algorithm, despite getting very close to showing $\mathsf{TreeEval} \in \mathsf{L}$, falls short, and in particular, it does not run in polynomial time. In this work, we present the first polynomial-time, almost logarithmic-space algorithm for $\mathsf{TreeEval}$. For any $\varepsilon>0$, our algorithm solves $\mathsf{TreeEval}$ in time $\mathrm{poly}(n)$ while using $O(\log^{1 +\varepsilon}n)$ space. Furthermore, our algorithm has the additional property that it requires only $O(\log n)$ bits of free space, and the rest can be catalytic space. Our approach is to trade off some (catalytic) space usage for a reduction in time complexity.

cs.CC↗

arXiv2026

Lower bounds on non-local computation from controllable correlation

Understanding entanglement cost in non-local quantum computation (NLQC) is relevant to complexity, cryptography, gravity, and other areas. This entanglement cost is largely uncharacterized; previous lower bound techniques apply to narrowly defined cases, and proving lower bounds on most simple unitaries has remained open. Here, we give two new lower bound techniques that can be evaluated for any unitary, based on their controllable correlation and controllable entanglement. For Haar random two qubit unitaries, our techniques typically lead to non-trivial lower bounds. Further, we obtain lower bounds on most of the commonly studied two qubit quantum gates, including CNOT, DCNOT, $\sqrt{\text{SWAP}}$, and the XX interaction, none of which previously had known lower bounds. For the CNOT gate, one of our techniques gives a tight lower bound, fully resolving its entanglement cost. The resulting lower bounds have parallel repetition properties, and apply in the noisy setting.

quant-ph↗

arXiv2025

Improved Clifford operations in constant commutative depth

The commutative depth model allows gates that commute with each other to be performed in parallel. We show how to compute Clifford operations in constant commutative depth more efficiently than was previously known. Bravyi, Maslov, and Nam [Phys. Rev. Lett. 129:230501, 2022] showed that every element of the Clifford group (on $n$ qubits) can be computed in commutative depth 23 and size $O(n^2)$. We show that the Prefix Sum problem can be computed in commutative depth 16 and size $O(n \log n)$, improving on the previous depth 18 and size $O(n^2)$ bounds. We also show that, for arbitrary Cliffords, the commutative depth bound can be reduced to 16. Finally, we show some lower bounds: that there exist Cliffords whose commutative depth is at least 4; and that there exist Cliffords for which any constant commutative depth circuit has size $\Omega(n^2)$.

quant-ph↗

arXiv2024

Linear gate bounds against natural functions for position-verification

A quantum position-verification scheme attempts to verify the spatial location of a prover. The prover is issued a challenge with quantum and classical inputs and must respond with appropriate timings. We consider two well-studied position-verification schemes known as $f$-routing and $f$-BB84. Both schemes require an honest prover to locally compute a classical function $f$ of inputs of length $n$, and manipulate $O(1)$ size quantum systems. We prove the number of quantum gates plus single qubit measurements needed to implement a function $f$ is lower bounded linearly by the communication complexity of $f$ in the simultaneous message passing model with shared entanglement. Taking $f(x,y)=\sum_i x_i y_i$ to be the inner product function, we obtain a $\Omega(n)$ lower bound on quantum gates plus single qubit measurements. The scheme is feasible for a prover with linear classical resources and $O(1)$ quantum resources, and secure against sub-linear quantum resources.

quant-ph↗

arXiv2019

Discrete-query quantum algorithm for NAND trees

Recently, Farhi, Goldstone, and Gutmann gave a quantum algorithm for evaluating NAND trees that runs in time O(sqrt(N log N)) in the Hamiltonian query model. In this note, we point out that their algorithm can be converted into an algorithm using O(N^{1/2 + epsilon}) queries in the conventional quantum query model, for any fixed epsilon > 0.

quant-ph↗

arXiv2019

Efficient Quantum Algorithms for Simulating Lindblad Evolution

We consider the natural generalization of the Schrödinger equation to Markovian open system dynamics: the so-called the Lindblad equation. We give a quantum algorithm for simulating the evolution of an $n$-qubit system for time $t$ within precision $ε$. If the Lindbladian consists of $\mathrm{poly}(n)$ operators that can each be expressed as a linear combination of $\mathrm{poly}(n)$ tensor products of Pauli operators then the gate cost of our algorithm is $O(t\, \mathrm{polylog}(t/ε)\mathrm{poly}(n))$. We also obtain similar bounds for the cases where the Lindbladian consists of local operators, and where the Lindbladian consists of sparse operators. This is remarkable in light of evidence that we provide indicating that the above efficiency is impossible to attain by first expressing Lindblad evolution as Schrödinger evolution on a larger system and tracing out the ancillary system: the cost of such a \textit{reduction} incurs an efficiency overhead of $O(t^2/ε)$ even before the Hamiltonian evolution simulation begins. Instead, the approach of our algorithm is to use a novel variation of the "linear combinations of unitaries" construction that pertains to channels.

quant-ph↗

arXiv2018

Constant gap between conventional strategies and those based on C*-dynamics for self-embezzlement

We consider a bipartite transformation that we call self-embezzlement and use it to prove a constant gap between the capabilities of two models of quantum information: the conventional model, where bipartite systems are represented by tensor products of Hilbert spaces; and a natural model of quantum information processing for abstract states on C*-algebras, where joint systems are represented by tensor products of C*-algebras. We call this the C*-circuit model and show that it is a special case of the commuting-operator model (in that it can be translated into such a model). For the conventional model, we show that there exists a constant $\epsilon_0 > 0$ such that self-embezzlement cannot be achieved with precision parameter less than $\epsilon_0$ (i.e., the fidelity cannot be greater than $1 - \epsilon_0$); whereas, in the C*-circuit model -- as well as in a commuting-operator model -- the precision can be $0$ (i.e., fidelity~$1$).

quant-ph↗

arXiv2016

Near-linear constructions of exact unitary 2-designs

A unitary 2-design can be viewed as a quantum analogue of a 2-universal hash function: it is indistinguishable from a truly random unitary by any procedure that queries it twice. We show that exact unitary 2-designs on n qubits can be implemented by quantum circuits consisting of ~O(n) elementary gates in logarithmic depth. This is essentially a quadratic improvement in size (and in width times depth) over all previous implementations that are exact or approximate (for sufficiently strong approximations).

quant-ph↗

arXiv2016

Perfect Embezzlement of Entanglement

Van Dam and Hayden introduced a concept commonly referred to as embezzlement, where, for any entangled quantum state $ϕ$, there is an entangled catalyst state $ψ$, from which a high fidelity approximation of $ϕ\otimes ψ$ can be produced using only local operations. We investigate a version of this where the embezzlement is perfect (i.e., the fidelity is 1). We prove that perfect embezzlement is impossible in a tensor product framework, even with infinite-dimensional Hilbert spaces and infinite entanglement entropy. Then we prove that perfect embezzlement is possible in a commuting operator framework. We prove this using the theory of C*-algebras and we also provide an explicit construction. Next, we apply our results to analyze perfect versions of a nonlocal game introduced by Regev and Vidick. Finally, we analyze the structure of perfect embezzlement protocols in the commuting operator model, showing that they require infinite-dimensional Hilbert spaces.

quant-ph↗

arXiv2016

Perfect Commuting-Operator Strategies for Linear System Games

Linear system games are a generalization of Mermin's magic square game introduced by Cleve and Mittal. They show that perfect strategies for linear system games in the tensor-product model of entanglement correspond to finite-dimensional operator solutions of a certain set of non-commutative equations. We investigate linear system games in the commuting-operator model of entanglement, where Alice and Bob's measurement operators act on a joint Hilbert space, and Alice's operators must commute with Bob's operators. We show that perfect strategies in this model correspond to possibly-infinite-dimensional operator solutions of the non-commutative equations. The proof is based around a finitely-presented group associated to the linear system which arises from the non-commutative equations.

quant-ph↗

arXiv2014

Simulating Hamiltonian dynamics with a truncated Taylor series

We describe a simple, efficient method for simulating Hamiltonian dynamics on a quantum computer by approximating the truncated Taylor series of the evolution operator. Our method can simulate the time evolution of a wide variety of physical systems. As in another recent algorithm, the cost of our method depends only logarithmically on the inverse of the desired precision, which is optimal. However, we simplify the algorithm and its analysis by using a method for implementing linear combinations of unitary operations to directly apply the truncated Taylor series.

quant-ph↗

arXiv2014

Exponential improvement in precision for simulating sparse Hamiltonians

We provide a quantum algorithm for simulating the dynamics of sparse Hamiltonians with complexity sublogarithmic in the inverse error, an exponential improvement over previous methods. Specifically, we show that a $d$-sparse Hamiltonian $H$ acting on $n$ qubits can be simulated for time $t$ with precision $ε$ using $O\big(τ\frac{\log(τ/ε)}{\log\log(τ/ε)}\big)$ queries and $O\big(τ\frac{\log^2(τ/ε)}{\log\log(τ/ε)}n\big)$ additional 2-qubit gates, where $τ= d^2 \|{H}\|_{\max} t$. Unlike previous approaches based on product formulas, the query complexity is independent of the number of qubits acted on, and for time-varying Hamiltonians, the gate complexity is logarithmic in the norm of the derivative of the Hamiltonian. Our algorithm is based on a significantly improved simulation of the continuous- and fractional-query models using discrete quantum queries, showing that the former models are not much more powerful than the discrete model even for very small error. We also simplify the analysis of this conversion, avoiding the need for a complex fault correction procedure. Our simplification relies on a new form of "oblivious amplitude amplification" that can be applied even though the reflection about the input state is unavailable. Finally, we prove new lower bounds showing that our algorithms are optimal as a function of the error.

quant-ph↗

arXiv2013

Exponential improvement in precision for Hamiltonian-evolution simulation

We provide a quantum method for simulating Hamiltonian evolution with complexity polynomial in the logarithm of the inverse error. This is an exponential improvement over existing methods for Hamiltonian simulation. In addition, its scaling with respect to time is close to linear, and its scaling with respect to the time derivative of the Hamiltonian is logarithmic. These scalings improve upon most existing methods. Our method is to use a compressed Lie-Trotter formula, based on recent ideas for efficient discrete-time simulations of continuous-time quantum query algorithms.

quant-ph↗

arXiv2013

Characterization of Binary Constraint System Games

We consider a class of nonlocal games that are related to binary constraint systems (BCSs) in a manner similar to the games implicit in the work of Mermin [N.D. Mermin, "Simple unified form for the major no-hidden-variables theorems," Phys. Rev. Lett., 65(27):3373-3376, 1990], but generalized to n binary variables and m constraints. We show that, whenever there is a perfect entangled protocol for such a game, there exists a set of binary observables with commutations and products similar to those exhibited by Mermin. We also show how to derive upper bounds strictly below 1 for the the maximum entangled success probability of some BCS games. These results are partial progress towards a larger project to determine the computational complexity of deciding whether a given instance of a BCS game admits a perfect entangled strategy or not.

quant-ph↗

arXiv2013

Gate-efficient discrete simulations of continuous-time quantum query algorithms

We show how to efficiently simulate continuous-time quantum query algorithms that run in time T in a manner that preserves the query complexity (within a polylogarithmic factor) while also incurring a small overhead cost in the total number of gates between queries. By small overhead, we mean T within a factor that is polylogarithmic in terms of T and a cost measure that reflects the cost of computing the driving Hamiltonian. This permits any continuous-time quantum algorithm based on an efficiently computable driving Hamiltonian to be converted into a gate-efficient algorithm with similar running time.

quant-ph↗

arXiv2012

Exact and Approximate Unitary 2-Designs: Constructions and Applications

We develop the concept of a unitary t-design as a means of expressing operationally useful subsets of the stochastic properties of the uniform (Haar) measure on the unitary group U(2^n) on n qubits. In particular, sets of unitaries forming 2-designs have wide applicability to quantum information protocols. We devise an O(n)-size in-place circuit construction for an approximate unitary 2-design. We then show that this can be used to construct an efficient protocol for experimentally characterizing the fidelity of a quantum process on n qubits with quantum circuits of size O(n) without requiring any ancilla qubits, thereby improving upon previous approaches.

quant-ph↗

arXiv2012

Reconstructing Strings from Substrings with Quantum Queries

This paper investigates the number of quantum queries made to solve the problem of reconstructing an unknown string from its substrings in a certain query model. More concretely, the goal of the problem is to identify an unknown string $S$ by making queries of the following form: "Is $s$ a substring of $S$?", where $s$ is a query string over the given alphabet. The number of queries required to identify the string $S$ is the query complexity of this problem. First we show a quantum algorithm that exactly identifies the string $S$ with at most $3/4N + o(N)$ queries, where $N$ is the length of $S$. This contrasts sharply with the classical query complexity $N$. Our algorithm uses Skiena and Sundaram's classical algorithm and the Grover search as subroutines. To make them effectively work, we develop another subroutine that finds a string appearing only once in $S$, which may have an independent interest. We also prove two lower bounds. The first one is a general lower bound of $Ω(\frac{N}{\log^2{N}})$, which means we cannot achieve a query complexity of $O(N^{1-ε})$ for any constant $ε$. The other one claims that if we cannot use queries of length roughly between $\log N$ and $3 \log N$, then we cannot achieve a query complexity of any sublinear function in $N$.

quant-ph↗