Tight Bounds on the Spooky Pebble Game: Recycling Qubits with Measurements

TL;DR

The paper investigates the spooky pebble game as a measurement-based method to recycle qubits in quantum simulations of classical sequential computation. It delivers asymptotically tight time-qubit trade-offs on the line, showing that any $T$-time, $S$-space computation can be implemented with $O(T/\varepsilon)$ gates and $O(T^{\varepsilon}S^{1-\varepsilon})$ qubits for any $\varepsilon \in (0,1]$, among complementary bounds. It further proves PSPACE-hardness for approximating minimum pebbles on general DAGs while providing efficient spooky pebbling strategies for complete binary trees with $h+1$ pebbles and $O(n\log n)$ steps, highlighting a practical qubit-saving advantage over reversible approaches. These results quantify the trade-offs between qubit usage and time in quantum simulations and offer guidance for designing measurements-based quantum algorithms.

Abstract

Pebble games are popular models for analyzing time-space trade-offs. In particular, the reversible pebble game is often applied in quantum algorithms like Grover's search to efficiently simulate classical computation on inputs in superposition. However, the reversible pebble game cannot harness the additional computational power granted by irreversible intermediate measurements. The spooky pebble game, which models interleaved measurements and adaptive phase corrections, reduces the number of qubits beyond what reversible approaches can achieve. While the spooky pebble game does not reduce the total space (bits plus qubits) complexity of the simulation, it reduces the amount of space that must be stored in qubits. We prove asymptotically tight trade-offs for the spooky pebble game on a line with any pebble bound, giving a tight time-qubit tradeoff for simulating arbitrary classical sequential computation with the spooky pebble game. For example, for all $ε\in (0,1]$, any classical computation requiring time $T$ and space $S$ can be implemented on a quantum computer using only $O(T/ ε)$ gates and $O(T^εS^{1-ε})$ qubits. This improves on the best known bound for the reversible pebble game with that number of qubits, which uses $O(2^{1/ε} T)$ gates. We also consider the spooky pebble game on more general directed acyclic graphs (DAGs), capturing fine-grained data dependency in computation. We show that for an arbitrary DAG even approximating the number of required pebbles in the spooky pebble game is PSPACE-hard. Despite this, we are able to construct a time-efficient strategy for pebbling binary trees that uses the minimum number of pebbles.

Figures (5)

• Figure 1: Summary of results on pebbling the line of length $n$. All asymptotics hold simultaneously for $n \to \infty$ and $\varepsilon \to 0$.
• Figure 2: Circuit to ghost $f(x)$ and later correct the phase in order to overall uncompute $f(x)$ using measurement-based uncomputing, as described in Gid19.
• Figure 3: The circuit from \ref{['fig-uncompute']} using G and $E_f$ circuit macros. Note that the $\bullet$ on the classical wire above the $E_f$ gate represents a controlled application of the component $Z$ gate rather than a controlled application of an entire module.
• Figure 4: Qubit efficient computation of $F(x) = f_5 \circ f_4 \circ f_3 \circ f_2 \circ f_1 (x)$ using ghosting. Again the $\bullet$ on the classical wire above the $E_{f_i}$ gates represents a controlled application of the component $Z$ gate rather than a controlled application of an entire module.
• Figure 5: A spooky pebbling of the line. Here $\circ$ indicates a pebble and $\sim$ indicates a ghost.

Theorems & Definitions (67)

• Proposition 2.1: Implicit in Ben89
• Definition 2.2
• Definition 2.3
• Definition 2.4
• Definition 2.5
• Definition 2.6
• Definition 2.7
• Definition 3.1
• Lemma 3.1
• proof