Span Programs and Quantum Space Complexity

While quantum computers hold the promise of significant computational speedups, the limited size of early quantum machines motivates the study of space-bounded quantum computation. We relate the quantum space complexity of computing a function f with one-sided error to the logarithm of its span program size, a classical quantity that is well-studied in attempts to prove formula size lower bounds. In the more natural bounded error model, we show that the amount of space needed for a unitary quantum algorithm to compute f with bounded (two-sided) error is lower bounded by the logarithm of its approximate span program size. Approximate span programs were introduced in the field of quantum algorithms but not studied classically. However, the approximate span program size of a function is a natural generalization of its span program size. While no non-trivial lower bound is known on the span program size (or approximate span program size) of any concrete function, a number of lower bounds are known on the monotone span program size. We show that the approximate monotone span program size of f is a lower bound on the space needed by quantum algorithms of a particular form, called monotone phase estimation algorithms, to compute f. We then give the first non-trivial lower bound on the approximate span program size of an explicit function.

💡 Research Summary

The paper investigates the relationship between quantum space complexity and a classical combinatorial measure known as span program size. A span program, introduced by Karchmer and Wigderson, is a linear‑algebraic model that decides a Boolean function f by checking whether a target vector lies in the span of a set of input‑dependent vectors. While previous work (Reichardt 2009, 2012) showed that the minimum size of a span program exactly characterizes the quantum query complexity of f, no connection to space complexity was known.

The authors first consider the one‑sided‑error unitary model, defining S₁U(f) as the minimum number of qubits required by a unitary quantum algorithm that computes f with one‑sided error. By adapting Reichardt’s construction that converts a span program into a quantum algorithm, they show that any such algorithm can be turned around into a span program whose size is at most 2^{S₁U(f)}. Consequently, S₁U(f) ≥ log SP(f), where SP(f) denotes the exact span‑program size of f. This gives a clean logarithmic lower bound on quantum space from a purely combinatorial quantity.

For the more natural bounded‑error (two‑sided) model, the paper introduces the notion of an approximate span program. An approximate span program relaxes the exact acceptance condition: the target vector only needs to be within a small additive error ε of the span generated by the input vectors. The authors prove that any bounded‑error unitary algorithm using T queries and S qubits can be transformed into an approximate span program of complexity Θ(T) and size 2^{Θ(S)}. Hence the bounded‑error unitary space complexity S_U(f) satisfies S_U(f) ≥ Ω(log f SP(f)), where f SP(f) is the minimum size of an approximate span program for f. This extends the query‑complexity correspondence to a space‑complexity correspondence.

Because proving non‑trivial lower bounds on (approximate) span‑program size for explicit functions is notoriously hard, the authors focus on the monotone setting. For a monotone Boolean function, a monotone span program restricts all vectors to be non‑negative, and its size is denoted mSP(f). They define a restricted class of quantum algorithms called monotone phase‑estimation algorithms: these algorithms perform a single query, embed the result into a unitary, and then run phase estimation while preserving monotonicity (adding zeros to the input can only increase the rejection probability). The paper shows that any bounded‑error monotone phase‑estimation algorithm must use at least log mf SP(f) qubits, where mf SP(f) is the approximate monotone span‑program size; similarly, one‑sided‑error monotone phase‑estimation algorithms need at least log mSP(f) qubits.

Using known monotone span‑program lower bounds, the authors obtain concrete quantum‑space lower bounds for this restricted model. Prior work gave mSP(f) ≥ 2^{Ω(log² n)} for certain explicit monotone functions (Babai‑Gál‑Wigderson 1999; Gál 2001). Applying their theorem yields a lower bound of Ω((log n)²) qubits for any bounded‑error monotone phase‑estimation algorithm solving such a function. Moreover, they construct an explicit function f for which mf SP(f) ≥ 2^{Ω((log n)²)}; this is the first non‑trivial lower bound on approximate monotone span‑program size.

The paper concludes with several open problems. The most prominent is to prove an ω(log n) lower bound on S_U(f) or S₁U(f) for any explicit total function, which would imply a super‑logarithmic quantum space requirement. The authors note that any quantum Turing machine using S space can be simulated classically in S² space, so a classical space lower bound of ω(log² n) would already yield a quantum bound. They also discuss extensions to hybrid quantum‑classical memory models, time‑space trade‑offs, and connections to matchgate circuit width and matrix inversion completeness. Overall, the work establishes span programs as a powerful bridge between classical circuit lower‑bound techniques and quantum space complexity, opening a new avenue for proving space lower bounds in the quantum regime.