Space-Bounded Quantum Interactive Proof Systems
Abstract
We introduce two models of space-bounded quantum interactive proof systems, and . The model, a space-bounded variant of quantum interactive proofs () introduced by Watrous (CC 2003) and Kitaev and Watrous (STOC 2000), restricts verifier actions to unitary circuits. In contrast, allows logarithmically many pinching intermediate measurements per verifier action, making it the weakest model that encompasses the classical model of Condon and Ladner (JCSS 1995).
We characterize the computational power of and . When the message number is polynomially bounded, unless :
- 
 
, a subclass of defined by a high-concentration condition on yes instances, exactly characterizes . 
- 
 
is contained in and contains , where denotes problems solvable by classical logarithmic-depth, semi-unbounded fan-in circuits. 
However, this distinction vanishes when is constant. Our results further indicate that (pinching) intermediate measurements uniquely impact space-bounded quantum interactive proofs, unlike in space-bounded quantum computation, where .
We also introduce space-bounded unitary quantum statistical zero-knowledge (), a specific form of proof systems with statistical zero-knowledge against any verifier. This class is a space-bounded variant of quantum statistical zero-knowledge () defined by Watrous (SICOMP 2009). We prove that , implying that the statistical zero-knowledge property negates the computational advantage typically gained from the interaction.
Keywords and phrases:
Intermediate measurements, Quantum interactive proofs, Space-bounded quantum computationFunding:
François Le Gall: Supported in part by JSPS KAKENHI grants Nos. JP20H05966, 20H00579, 24H00071, and by MEXT JST CREST grant No. JPMJCR24I4.Copyright and License:
![[Uncaptioned image]](x1.png) © François Le Gall, Yupan Liu, Harumichi Nishimura, and Qisheng Wang; licensed under Creative Commons License CC-BY 4.0
 © François Le Gall, Yupan Liu, Harumichi Nishimura, and Qisheng Wang; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Interactive proof systems ; Theory of computation Complexity classes ; Theory of computation Quantum complexity theoryAcknowledgements:
The authors appreciate Dorian Rudolph for pointing out a gap in the earlier argument that QIPL is contained in AM, specifically noting that Lemma 3.14 in the full version [41] does not directly apply to QIPL, as it does not verify the consistency of the prover strategies across different measurement outcome branches. YL is grateful to Uma Girish for a helpful discussion that inspired Question c. The authors also thank the anonymous reviewers for their helpful comments, which made the introduction more accessible to non-expert readers.Funding:
This work was partially supported by MEXT Q-LEAP grant No. JPMXS0120319794.Editors:
Srikanth SrinivasanSeries and Publisher:
 Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
 Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Background
Recent advancements in quantum computation with a limited number of qubits have been achieved from both theoretical and experimental perspectives. Theoretical work began in the late 1990s, focusing on feasible models of quantum computation operating under space restrictions, where the circuit acts on qubits and consists of elementary gates [61, 64]. These models, referred to as quantum logspace, were later shown during the 2010s to offer a quadratic space advantage for certain problems over the best known classical algorithms [57, 18], which saturates the classical simulation bound. In recent years, this area has gained increased attention, particularly in eliminating (pinching) intermediate measurements in these models [19, 26], and through further developments [25, 68]. Motivated by these achievements in quantum logspace, we are interested in exploring the power of the quantum interactive proof systems where the verifier is restricted to quantum logspace.
To put it simply, in a single-prover (quantum) interactive proof system for a promise problem , a computationally weak (possibly quantum) verifier interacts with a computationally all-powerful but untrusted prover. In quantum scenarios, the prover and verifier may share entanglement during their interactions. Given an input , the prover claims that , but the verifier does not simply accept this claim. Instead, an interactive protocol is initiated, after which the verifier either “accepts” or “rejects” the claim. The protocol has completeness parameter , meaning that if is in and the prover honestly follows the protocol, the verifier accepts with probability at least . The protocol has soundness parameter , meaning that if is in then the verifier accepts with probability at most , regardless of whether the prover follows the protocol. Typically, an interactive protocol for has completeness and soundness .
1.1 Interactive proof systems with time-bounded verifier
The exploration of classical interactive proof systems (IP) was initiated in the 1980s [4, 29]. In these proof systems, the verifier is typically bounded by polynomial time, and represents interactive protocols involving messages during interactions. Particularly, when the verifier’s messages are merely random bits, these public-coin proof systems are known as Arthur-Merlin proof systems [4]. Shortly thereafter, it was established that any constant-message IP protocol can be parallelized to a two-message public-coin protocol, captured by the class AM, and thus is contained in the second level of the polynomial-time hierarchy [4, 30]. However, IP protocols with a polynomial number of messages have been shown to be exceptionally powerful, as demonstrated by the seminal result [46, 56]. Consequently, IP protocols with a polynomial number of messages generally cannot be parallelized to a constant number of messages unless the polynomial-time hierarchy collapses.111The assumption that the polynomial-time hierarchy does not collapse generalizes the conjecture that .
About fifteen years after the introduction of interactive proof systems (and a model of quantum computation), the study of quantum interactive proof systems (QIP) began [63]. Remarkably, any QIP protocol with a polynomial number of messages can be parallelized to three messages [37]. A quantum Arthur-Merlin proof system was subsequently introduced in [47], and any three-message QIP protocol can be transformed into this form (QMAM). By the late 2000s, the computational power of QIP was fully characterized: The celebrated result [35] established that QIP is not more powerful than IP as long as the gap is at least polynomially small. However, when the gap is double-exponentially small, this variant of QIP is precisely characterized by EXP [33]. In the late 2010s, another quantum counterpart of the Arthur-Merlin proof system was considered in [39], where the verifier’s message is either random bits or halves of EPR pairs, leading to a quadrichotomy theorem that classifies the corresponding QIP protocols.
1.2 Interactive proof systems with space-bounded verifier
The investigation of (classical) interactive proof systems with space-bounded verifiers started in the late 1980s [16, 8], alongside research on time-bounded verifiers. Notably, by using the fingerprinting lemma [44], Condon and Ladner [10] showed that the class of (private-coin) classical interactive proof systems with logarithmic-space verifiers using random bits exactly characterizes NP. In parallel, public-coin space-bounded classical interactive proofs were explored in the early 1990s [21, 20, 9]. By around 2010, it was established that such space-bounded protocols with public coins precisely characterize P [28].
Space-bounded Merlin-Arthur-type proof systems were also studied in the early 1990s. In particular, when the verifier operates in classical logspace with random bits and has online access to a -bit message, the proof system exactly characterizes NP [44]. More recently, restricting the computational power of the honest prover to quantum logspace (BQL) has led to a counterpart classical proof system that exactly characterizes BQL [27].
Although research has been conducted on quantum interactive proofs where the verifier uses quantum finite automata [51, 52, 67], analogous to classical work [16], to our knowledge no prior work has addressed space-bounded counterparts of quantum interactive proofs that align with the circuit-based model defined in [37, 63]. In the case without interaction, space-bounded quantum Merlin-Arthur proof systems have been studied recently. When the verifier has direct access to an -qubit message, meaning it can process the message directly in its workspace qubits, this variant (QMAL) is as weak as BQL [17, 19]. However, when the (unitary) verifier has online access to a -qubit message, where each qubit in the message state is read-once, this variant is as strong as QMA [24].222An exponentially up-scaled quantum counterpart of the space-bounded Merlin-Arthur-type proof system from [44], with classical messages, was also considered in [24]. The variant with unitary quantum polynomial-space verifier, implicitly allowing random bits, precisely corresponds to NEXP.
It is important to note that online and direct access to messages during interactions makes no difference for time-bounded interactive or Merlin-Arthur-type proof systems, whether classical or quantum. This distinction arises from the nature of space-bounded computation.
2 Main results
2.1 Definitions of QIPL and QIPUL
We introduce space-bounded quantum interactive proof systems and their unitary variant, denoted as QIPL and QIPUL, respectively. In these proof systems, the verifier operates in quantum logspace and has direct access to messages during interaction with the prover . Specifically, in a -turn (message) space-bounded quantum interactive proof system for a promise problem , this proof system consists of the prover’s private register , the message register , and the verifier’s private register . Both and are of size , with being accessible to both the prover and the verifier.333Our definitions of QIPL and QIPUL can be straightforwardly extended to the corresponding proof systems with an odd number of messages, as shown in [41, Figure 4.1].
The verifier maps an input to a sequence , with for representing the verifier’s actions at the -th turn, and representing the verifier’s action just before the final measurement. The primary difference between QIPL and QIPUL proof systems lies in the verifier’s action for :
- 
 
In QIPL proof systems, each corresponds to an almost-unitary quantum circuit that includes pinching intermediate measurements in the computational basis.444We note that restricting the number of pinching measurements in each verifier turn from polynomial in to does not cause any loss of generality, provided that the QIPL proof system has a polynomial number of turns. See [41, Remark 3.5] for further details. Each such measurement maps a single-qubit state to .555Pinching intermediate measurements naturally arise in space-bounded quantum computation, particularly in recent developments on eliminating intermediate measurements in quantum logspace [26, 25]. In this context, the quantum channels that capture the space-bounded computation are unital in the case of qubits. The bound reflects the maximum number of measurement outcomes that can be stored in logspace, aligning with the verifier’s direct access to the message. For convenience, we apply the principle of deferred measurements (e.g., [50, Section 4.4]), transforming the circuit into an isometric quantum circuit with a newly introduced environment register ,666An -qubit isometric quantum circuit utilizes ancillary gates, with each ancillary gate introducing an ancillary qubit . For further details, please refer to [41, Definition 2.8]. which is measured at the end of that turn, with the measurement outcome denoted by , as illustrated in Figure 1. Furthermore, each environment register remains private to the verifier and becomes inaccessible after the round that starts with the verifier’s -th action. 
- 
 
In QIPUL proof systems, each is a unitary quantum circuit. 
The prover’s actions can be similarly described by unitary quantum circuits. A proof system is said to accept if, after the verifier performs and measures the designated output qubit in the computational basis, the outcome is . Additionally, we require a strong notion of uniformity for the verifier’s mapping: the description of the sequence must be computable by a single deterministic logspace Turing machine.777A weaker notion of uniformity only requires that the description of each can be individually computed by a deterministic logspace Turing machine. It is important to note that these distinctions do not arise in the time-bounded setting, as the composition of a polynomial number of deterministic polynomial-time Turing machines can be treated as a single deterministic polynomial-time Turing machine.
Lastly, for QIPLHC proof systems, we impose an additional restriction on yes instances: the distribution of intermediate measurement outcomes , conditioned on acceptance, must be highly concentrated. More precisely, let be the contribution of to , where is the maximum acceptance probability of . Then, there must exist a such that .
We denote -turn space-bounded quantum interactive proof systems with completeness and soundness as , and their unitary variant as . In particular, we adopt the following notations, which naturally extend to QIPUL:
In constant-turn scenarios, it is crucial to emphasize that the proof systems and can directly simulate each other, as the environment registers collectively holds qubits.888This equivalence follows directly from the principle of deferred measurements. However, for constant-turn space-bounded quantum interactive proofs, allowing each verifier action to involve pinching intermediate measurements might increase the proof system’s power beyond the unitary case. This is because current techniques for proving results such as [19, 26, 25] do not directly apply in this context. Therefore, for simplicity, we define proof systems in which the verifier’s actions are implemented by unitary quantum circuits.
2.2 Space-bounded (unitary) quantum interactive proofs
Our first theorem serves as a quantum analog of the classical work by Condon and Ladner [10]:
Theorem 1 (Informal of [41, Theorem 3.1]).
Interestingly, Theorem 1 suggests that the QIPLHC model can be viewed as the weakest model that encompasses space-bounded (private-coin) classical interactive proofs, as considered in [10]. Our definitions of QIPL and its subclass QIPLHC aim to introduce quantum counterparts that include these classical proof systems, ensuring that soundness against classical messages also holds for quantum messages. Similar soundness issues challenged multi-prover scenarios (e.g., proving ) for nearly a decade [7, 34], while in the single-prover settings (e.g., proving ), it is typically resolved by measuring the prover’s quantum messages and treating the outcomes as classical messages (e.g., [1, Claim 1]).
However, space-bounded unitary quantum interactive proofs (QIPUL), which denote the most natural space-bounded counterpart to quantum interactive proofs as defined in [37, 64], do not directly achieve the stated soundness guarantee. Hence, QIPUL may be computationally weaker than QIPL. Our second theorem characterizes the computational power of QIPUL:
Theorem 2 (Informal of [41, Theorems 3.3 and 4.2]).
The following holds:
Theorems 1 and 2 suggest that QIPUL is indeed weaker than QIPL unless . Interestingly, this distinction from the unitary case arises even when each verifier action is slightly more powerful than a unitary quantum circuit. It is also noteworthy that the class is equivalent to LOGCFL [59], which contains NL and is contained in .999For more details on the computational power of and related complexity classes, see [41, Section 2.4]. Our third theorem, meanwhile, focuses on space-bounded quantum interactive proof systems with a constant number of messages:
Theorem 3 (Informal of [41, Theorem 4.3]).
For any ,
To compare with time-bounded classical or quantum interactive proofs, we summarize our three theorems in Table 1. Notably, our two models of space-bounded quantum interactive proofs, QIPL and QIPUL, demonstrate behavior that is distinct from both:
- 
 
For (time-bounded) classical interactive proofs, all proof systems with (the regime of the last row in Table 1) are contained in the second level of the polynomial-time hierarchy [4, 30], whereas the class of proof systems with (the regime of the second and third rows in Table 1) exactly characterizes PSPACE [46, 56]. 
| Models | Constant gap | Polynomial small gap | |
|---|---|---|---|
| The number of messages: | NP | NP | |
| Theorem 1 | Theorem 1 | ||
| The number of messages: | QIPUL | contains & in P | contains & in P | 
| Theorem 2 | Theorem 2 | ||
| The number of messages: | QIPL & QIPUL | in NC | contains & in P | 
| Theorem 3 | Theorem 2 | 
The central intuition underlying Table 1 is that parallelization [37, 36], perhaps the most striking complexity-theoretic property of QIP proof systems, distinguishes QIPUL from QIPL. Quantum logspace operates within a polynomial-dimensional Hilbert space, remaining computationally weak even with a constant number of interactions, and is (at least) contained in P. In QIPUL, the verifier’s actions are reversible and dimension-preserving, allowing direct application of parallelization techniques from [36]. In contrast, QIPL and its reversible generalization lack dimension preservation, requiring significantly more than space to parallelize the verifier’s actions, which prevents parallelization.
2.3 Space-bounded unitary quantum statistical zero-knowledge
We also introduce (honest-verifier) space-bounded unitary quantum statistical zero-knowledge, denoted as QSZKULHV. This term refers to a specific form of space-bounded quantum proofs that possess statistical zero-knowledge against an honest verifier. Specifically, a space-bounded unitary quantum interactive proof system possesses this zero-knowledge property if there exists a quantum logspace simulator that approximates the snapshot states (“the verifier’s view”) on the registers and after each turn of this proof system, where each state approximation must be very close (“indistinguishable”) to the corresponding snapshot state with respect to the trace distance.
Our definition QSZKULHV serves as a space-bounded variant of honest-verifier (unitary) quantum statistical zero-knowledge, denoted by QSZKHV, as introduced in [62]. Our fourth theorem establishes that the statistical zero-knowledge property completely negates the computational advantage typically gained through the interaction:
Theorem 4 (Informal of [41, Theorem 5.2]).
In addition to QSZKULHV, we can define QSZKUL in line with [65], particularly considering space-bounded unitary quantum statistical zero-knowledge against any verifier (rather than an honest verifier). Following this definition, . Interestingly, Theorem 4 serves as a direct space-bounded counterpart to [65].
The intuition behind Theorem 4 is that the snapshot states after each turn capture all the essential information in the proof system, such as allowing optimal prover strategies to be “recovered” from these states [48, Section 7]. In space-bounded scenarios, space-efficient quantum singular value transformation [42] enables fully utilizing this information.
3 Proof techniques
Standard techniques for quantum interactive proofs are typically developed under the restriction that the verifier is unitary. While this restriction does not limit generality in time-bounded settings (e.g., see [60, Section 4.1.4]), it presents difficulties in the context of space-bounded quantum interactive proofs, where verifiers may not be unitary. In what follows, we highlight the challenges that arise and briefly explain how we address them.
3.1 Upper bounds for QIPLHC and QIPUL
3.1.1
We prove this inclusion using a semi-definite program (SDP) for a given QIPLO(1) proof system, adapted from the SDP formulation for QIP in [60, 66]. Together with the turn-halving lemma, specifically Theorem 53, this inclusion implies that .
Consider a -turn QIPLO(1) proof system , where . Let and , for , denote snapshot states in the register and after the -st turn and the -th turn in , respectively, as illustrated in [41, Figure 3.1]. The variables in this SDP correspond to these snapshot states after each prover’s action, particularly for , while the objective function is the maximum acceptance probability of . Since the verifier’s actions are unitary circuits, these variables can be treated independently. Hence, the SDP program mainly consists of two types of constraints, assuming that all variables are valid quantum states:
- 
(i) 
Verifier’s actions only operate on the registers and : 
- 
(ii) 
Prover’s actions do not change the verifier’s private register: (1) 
Since the variables in this SDP collectively hold qubits, a standard SDP solver (e.g., [23]) provides a deterministic polynomial-time algorithm for approximately solving it.
3.1.2
We now extend the above SDP formulation to -round QIPL proof systems, in which the verifier’s -th action is an almost-unitary quantum circuit that allows pinching intermediate measurements. For simplicity, we instead consider the corresponding isometric quantum circuit , which introduces a new environment register measured at the end of the turn, with the outcome denoted by .
Recall that represents the contribution of the measurement outcome branch to the maximum acceptance probability . Owing to the high-concentration condition, it suffices to consider an approximation of for some specific branch , satisfying
These bounds follow from two facts: (1) pinching measurements eliminate coherence between subspaces corresponding to different branches, which enables to be approximately optimized in isolation; and (2) the acceptance probability of any associated global prover strategy across all branches cannot exceed .
By extending the SDP formulation of QIPLO(1) proof systems, we construct a family of SDP programs depending on the measurement outcome branches . Let denote the unnormalized snapshot states after measuring . For a fixed branch , the associated SDP program includes the following three types of constraints:
- 
(i’) 
for , and 
- 
(ii’) 
for . 
- 
(iii’) 
for . 
Notably, for the third type of constraints, both sides evaluate to exactly when the verifier is unitary, as in the cases of QIP and QIPUL. In contrast, for QIPL proof systems, the value varies across different measurement outcome branches and remains bounded above by . Crucially, this value is entirely determined by the verifier’s actions and cannot be altered by the prover.
Next, we explain the NP containment. The classical witness consists of an -tuple , indicating a specific SDP program, and a feasible solution to this SDP program. This solution can be represented by square matrices of dimension , thus having polynomial size. The verification procedure involves checking (1) whether the solution encoded in satisfies these SDP constraints based on ; and (2) whether . All these checks can be verified using basic matrix operations in deterministic polynomial time.
3.2 Basic properties for QIPL and QIPUL
We begin by outlining three basic properties of space-bounded (unitary) quantum interactive proof systems, which are dependent on the parameters , , and :
Theorem 5 (Properties for QIPL and QIPUL, informal of [41, Theorem 3.2 and Lemma 4.5]).
Let , , and be functions such that , , and . Then, it holds that:
- 
(1) 
Closure under perfect completeness. 
- 
(2) 
Error reduction. For any polynomial , Here, . 
- 
(3) 
Parallelization. . 
Achieving perfect completeness for QIPL and QIPUL proof systems, particularly Theorem 51, can be adapted from the techniques used in QIP proof systems [60, Section 4.2.1] (or [37, Section 3]) by adding two additional turns. However, there are important subtleties to consider when establishing the other properties in Theorem 5.
3.2.1 Error reduction via sequential repetition
Since each message is of size , error reduction via parallel repetition does not apply to QIPL and QIPUL when the gap is polynomially small, regardless of the number of messages.101010Still, error reduction via parallel repetition works for QIPL when the gap ; see [41, Lemma 4.4]. Alternatively, error reduction via sequential repetition requires that the registers and (the “workspace”) must be in the all-zero state (“cleaned”) before each execution of the original proof systems. While this is trivial for QIP proof systems, it poses a challenge for QIPL and QIPUL proof systems because the (almost-)unitary quantum logspace verifier cannot achieve this on its own.
To establish Theorem 52, our solution is to have the prover “clean” the workspace while ensuring that the prover behaves honestly. This is achieved through the following proof system: The verifier applies a multiple-controlled adder before each proof system execution, with the adder being activated only when the control qubits are all zero. The verifier then measures the register that the adder acts on and accepts if (1) the workspace is “cleaned” for each execution and (2) all outcomes of the original proof system executions are acceptance.
3.2.2 Parallelization and strict uniformity condition for the verifier’s mapping
The original parallelization technique proposed in [37, Section 4] applies only to QIPUL (also QIPL) proof systems with a constant number of messages. This limitation stems from the requirement that the prover sends the snapshot states for all turns in a single message. As increases, the size of this message grows to , which becomes when .
To overcome this issue, we adapt the technique from [36, Section 4], a “dequantized” version of the original approach that fully utilizes the reversibility of the verifier’s actions. Instead of sending all snapshot states in one message, the new verifier performs the original verifier’s action or its reverse at any turn in a single action. Specifically, when applying this method to a -turn QIPUL proof system , the prover starts by sending only the snapshot state after the -st turn. The verifier then chooses uniformly at random: if , the verifier continues to interact with the prover according to , keeping the acceptance condition unchanged; while if , the verifier executes in reverse, and finally accepts if its private qubits are all zero. This proof system, which halves the number of turns, is referred to as the turn-halving lemma, as detailed in Theorem 53.
Next, we establish Theorem 2 by applying the turn-halving lemma times.111111An operation based on random bits can be simulated by a corresponding unitary controlled by the state , where . Thus, simulating random bits across all turns of the proof system requires ancillary qubits in total, which is feasible for the unitary quantum logspace verifier in QIPUL. Specifically, any QIPUL proof system with a polynomial number of messages can be parallelized to three messages,121212Although the turn-halving lemma does not directly apply to QIPL proof systems, a similar reasoning works for its reversible generalization , reducing a constant number of messages to three. while the gap of the resulting proof system becomes polynomially small. However, this reasoning poses a challenge: the resulting verifier must know all original verifier actions, necessitating a strong notion of uniformity for the verifier’s mapping in our definition of QIPUL. In addition, to prove Theorem 3, we adopt a similar approach to that used for QIP, particularly [47], which inspired the turn-halving lemma [36, Section 4], and an exponentially down-scaling version of the work [35].
3.3 Lower bounds for QIPL and QIPUL
3.3.1
This inclusion draws inspiration from the interactive proof system in [10, Lemma 2] and presents a challenge in adapting this proof system to the QIPL setting. Notably, our construction essentially provides a QIPLHC proof system, since the pinching measurement outcomes are unique (even stronger than the high-concentration condition) for yes instances.
We start by outlining this QIPL proof system for 3-SAT. Consider a 3-SAT formula
with clauses and variables. An assignment of assigns each variable for a value of either (true) or (false). To verify whether is satisfied by the assignment , we encode as , consisting of triples , where denotes the literal (either or ), represents the -th clause, and denotes the value assigned to . The prover’s actions are divided into two phases:
- 
(i) 
Consistency Check (for variables). The prover sends one by one all the triples in , ordered by the variable corresponding to the literal ; 
- 
(ii) 
Satisfiability Check (for clauses). For each , the prover sends the three triples , , and in . 
The verifier’s actions are as follows. To prevent the prover from entangling with the verifier and revealing the private coins, the verifier measures the received messages in the computational basis at the beginning of each action, interpreting the measurement outcomes as the prover’s messages. Therefore, it suffices to establish soundness against classical messages.
We now focus on this specific proof system. In Phase (i), the verifier checks whether the assigned values to the same variable are consistent. Since the verifier’s actions are almost-unitary circuits and cannot discard information, this seems challenging. Our solution is that the verifier keeps only the current and the previous triples, returning the previous triple to the prover in the next turn. In Phase (ii), the verifier checks whether each batch of three triples is satisfied and returns them immediately. Lastly, to ensure that the multisets of triples from Phase (i) and (ii) are identical, the verifier computes the “fingerprint” of these multisets,131313See [41, Section 2.4] for the definition of the fingerprint of a multiset. The computation of each fingerprint requires random bits, which can be simulated in a QIPL proof system; see Footnote 11 for details. triple by triple, and compares the fingerprints from both phases at the end. The verifier accepts if all checks succeed.
3.3.2
This inclusion is inspired by the interactive proof system in [21, Section 3.4]. By using error reduction for QIPUL, specifically Theorem 52, it remains to demonstrate that . A Boolean circuit is defined as a (uniform) circuit if it is an -depth Boolean circuit that employs unbounded fan-in OR gates, bounded fan-in AND gates, and negation gates at the input level.
The interactive proof system for evaluating the circuit starts at its top gate. If the gate is an OR, the prover selects a child gate; if it’s an AND, the verifier flips a coin to select one. This process repeats until reaching an input or its negation, with the verifier accepting if or , respectively. Since the computational paths in do not interfere, extending soundness against classical messages, following directly from [21, Section 3.4], to quantum messages can be done by measuring the registers and in the computational basis at the end of the verifier’s last turn. Finally, given that has depth, implementing the verifier’s actions requires only ancillary qubits, which is indeed achievable by a unitary verifier.
3.4 The equivalence of QSZKUL and BQL
We demonstrate Theorem 4 by introducing a QSZKULHV-complete problem:
Theorem 6 (Informal of [41, Theorem 5.3]).
IndivProdQSD is QSZKULHV-complete.
We begin by informally defining the promise problem Individual Product State Distinguishability, denoted by , where the parameters satisfy and . This problem considers two -tuples of -qubit quantum states, denoted by and , where the purifications of these states can be prepared by corresponding polynomial-size unitary quantum circuits acting on qubits. For yes instances, these two -tuples are “globally” far, satisfying
| (2) | 
While for no instances, each pair of corresponding states in these -tuples are close, satisfying
| (3) | 
Then we show that (1) the complement of IndivProdQSD, , is QSZKULHV-hard; and (2) IndivProdQSD is in BQL, which is contained in QSZKULHV by definition.
3.4.1 is QSZKULHV-hard
The hardness proof draws inspiration from [62, Section 5]. Consider a proof system, denoted by . The logspace-bounded simulator produces good state approximations and of the snapshot states and after the -st turn and the -th turn in , respectively, satisfying and , where is a negligible function.
Since the verifier’s actions are unitary and the verifier is honest, it suffices to check that the prover’s actions do not change the verifier’s private register, corresponding to the type (ii) constraints Equation 1 in the SDP formulation for QIPL proof systems. For convenience, let and for . We then establish QSZKLHV hardness as follows:
- 
 
For yes instances, the message-wise closeness condition of the simulator implies Equation 3 with . 
- 
 
For no instances, the simulator produces the snapshot state before the final measurement, which accepts with probability for all instances, while the proof system accepts with probability at most . The inconsistency between the simulator’s state approximations and the snapshot states yields Equation 2 with . 
3.4.2
Since it holds that [17, 19], it suffices to establish that . By applying an averaging argument in combination with Equation 2, we derive the following:
| (4) | 
The QMAL protocol works as follows: (1) The prover sends an index to the verifier; and (2) The verifier accepts if and rejects if , in accordance with Equations 4 and 3. The resulting promise problem to be verified is precisely an instance of GapQSDlog, which is known to be BQL-complete [42].
4 Discussion and open problems
We introduce two models of space-bounded quantum interactive proof systems: QIPL and QIPUL. Unlike , we show that unless . Our results highlight the distinctive role of (pinching) intermediate measurements in space-bounded quantum interactive proofs, setting them apart from space-bounded quantum computation. This prompts an intriguing question:
- 
(a) 
What is the computational power of space-bounded quantum interactive proofs beyond QIPLHC, particularly when the high-concentration requirement for yes instances (the completeness condition) is removed, as in the class QIPL, or when the verifier is allowed to perform general quantum logspace computations? 
A motivating example is a reversible generalization of QIPL, particularly space-bounded isometric quantum interactive proof systems (, see [41, Remark 3.8]), where all verifier actions are -qubit isometric quantum circuits. Remarkably, at least contains QMA: Given a local Hamiltonian , we can construct a proof system as follows:141414A similar approach is used in a streaming version of QMAL (with online access to the message) in [24].
- 
(i) 
The verifier chooses a local term uniformly at random from the set . 
- 
(ii) 
The prover sends a ground state qubit by qubit, while the verifier sends a state in each round and retains only the qubits associated with in its private registers. 
- 
(iii) 
The verifier performs the POVM corresponding to the decomposition .151515See the proof of [38, Proposition 14.2] for an explicit construction of such POVMs. 
Further analysis indicates that the verifier accepts with probability , and direct sequential repetition yields a proof system. Additionally, it is evident that all candidate models of Question a are contained in QIP, and thus in PSPACE.
Furthermore, space-bounded unitary quantum interactive proofs (QIPUL) can simulate the classical counterparts with public coins [21] (see Theorem 2), raising the question:
- (b)
Finally, for constant-turn space-bounded quantum interactive proofs, the three models discussed here become equivalent due to the principle of deferred measurements, contrasting with the aforementioned polynomial-turn settings. However, this equivalence does not directly extend to more general verifiers (see Footnote 8), leading to the following question:
- 
(c) 
What is the computational power of constant-turn space-bounded quantum interactive proofs with a general quantum logspace verifier? 
5 Related works
Variants of time-bounded quantum interactive proofs with short messages were explored in [5, 53]. Depending on the settings, these variants are as powerful as QMA or BQP.
The concept of interactive proof systems has been extended to other computational models. Quantum interactive proofs for synthesizing quantum states, known as , were introduced in [55]. Follow-up research established the equivalence [48] and developed a parallelization technique for [32, 54]. A Merlin-Arthur-type variant was also explored in [14, 13]. More recently, quantum interactive proofs for unitary synthesis and related problems have been studied in [6, 45]. Another interesting but less related variant is the exploration of interactive proof systems in distributed computing [40, 49], and more recently, quantum distributed interactive proof systems have been investigated [22, 43, 31].
Finally, space-bounded (classical) statistical zero-knowledge, where the verifier has read-only (i.e., two-way) access to (polynomial-length) messages during interactions, was studied in [15, 3, 2]. More recently, a variant where the verifier has online (i.e., one-way) access to messages has also been explored [12].
References
- [1] Dorit Aharonov and Tomer Naveh. Quantum NP – a survey. arXiv preprint quant-ph/0210077, 2002. arXiv:quant-ph/0210077.
- [2] Eric Allender, Jacob Gray, Saachi Mutreja, Harsha Tirumala, and Pengxiang Wang. Robustness for space-bounded statistical zero knowledge. In Proceedings of the International Workshop on Randomization and Computation, volume 275 of LIPIcs, pages 56:1–56:21, 2023. ECCC:TR22-138. doi:10.4230/LIPICS.APPROX/RANDOM.2023.56.
- [3] Eric Allender, Shuichi Hirahara, and Harsha Tirumala. Kolmogorov complexity characterizes statistical zero knowledge. In Proceedings of the 14th Innovations in Theoretical Computer Science Conference, volume 251, pages 3:1–3:19, 2023. ECCC:TR22-127.
- [4] László Babai. Trading group theory for randomness. In Proceedings of the 17th Annual ACM Symposium on Theory of Computing, pages 421–429, 1985. doi:10.1145/22145.22192.
- [5] Salman Beigi, Peter Shor, and John Watrous. Quantum interactive proofs with short messages. Theory of Computing, 7(1):101–117, 2011. arXiv:1004.0411. doi:10.4086/toc.2011.v007a007.
- [6] John Bostanci, Yuval Efron, Tony Metger, Alexander Poremba, Luowen Qian, and Henry Yuen. Unitary complexity and the Uhlmann transformation problem. arXiv preprint, 2023. arXiv:2306.13073.
- [7] Richard Cleve, Peter Høyer, Benjamin Toner, and John Watrous. Consequences and limits of nonlocal strategies. In 19th Annual IEEE Conference on Computational Complexity (CCC 2004), 21-24 June 2004, Amherst, MA, USA, pages 236–249. IEEE Computer Society, 2004. arXiv:quant-ph/0404076. doi:10.1109/CCC.2004.1313847.
- [8] Anne Condon. Space-bounded probabilistic game automata. Journal of the ACM, 38(2):472–494, 1991. Preliminary Version in SCT 1988. doi:10.1145/103516.128681.
- [9] Anne Condon. The complexity of space boundes interactive proof systems. In Complexity Theory: Current Research, pages 147–189. Cambridge University Press, 1992. URL: https://dl.acm.org/doi/10.5555/183589.183728.
- [10] Anne Condon and Richard Ladner. Interactive proof systems with polynomially bounded strategies. Journal of Computer and System Sciences, 50(3):506–518, 1995. Preliminary Version in SCT 1992. doi:10.1006/jcss.1995.1040.
- [11] Joshua Cook and Ron D. Rothblum. Efficient interactive proofs for non-deterministic bounded space. In Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques (APPROX/RANDOM 2023), volume 275 of LIPIcs, pages 47:1–47:22. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. ECCC:TR23-097. doi:10.4230/LIPIcs.APPROX/RANDOM.2023.47.
- [12] Graham Cormode, Marcel de Sena Dall’Agnol, Tom Gur, and Chris Hickey. Streaming zero-knowledge proofs. In Proceedings of the 39th Computational Complexity Conference, volume 300 of LIPIcs, pages 2:1–2:66. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2024. arXiv:2301.02161. doi:10.4230/LIPICS.CCC.2024.2.
- [13] Hugo Delavenne and François Le Gall. Quantum state synthesis: Relation with decision complexity classes and impossibility of synthesis error reduction. Quantum Information and Computation, 24(9-10):754–765, 2024. arXiv:2407.02907. doi:10.26421/qic24.9-10-3.
- [14] Hugo Delavenne, François Le Gall, Yupan Liu, and Masayuki Miyamoto. Quantum Merlin-Arthur proof systems for synthesizing quantum states. Quantum, 9:1688, 2025. arXiv:2303.01877. doi:10.22331/q-2025-04-03-1688.
- [15] Zeev Dvir, Dan Gutfreund, Guy N. Rothblum, and Salil P. Vadhan. On approximating the entropy of polynomial mappings. In Proceedings of Second Symposium on Innovations in Computer Science, pages 460–475, 2011. URL: https://conference.iiis.tsinghua.edu.cn/ICS2011/content/papers/28.html.
- [16] Cynthia Dwork and Larry Stockmeyer. Finite state verifiers I: The power of interaction. Journal of the ACM, 39(4):800–828, 1992. Preliminary Version in FOCS 1989. doi:10.1145/146585.146599.
- [17] Bill Fefferman, Hirotada Kobayashi, Cedric Yen-Yu Lin, Tomoyuki Morimae, and Harumichi Nishimura. Space-efficient error reduction for unitary quantum computations. In Proceedings of the 43rd International Colloquium on Automata, Languages, and Programming, volume 55 of LIPIcs, page 14, 2016. arXiv:1604.08192. doi:10.4230/LIPIcs.ICALP.2016.14.
- [18] Bill Fefferman and Cedric Yen-Yu Lin. A complete characterization of unitary quantum space. In Proceedings of the 9th Innovations in Theoretical Computer Science Conference, volume 94 of LIPIcs, page 4, 2018. arXiv:1604.01384. doi:10.4230/LIPIcs.ITCS.2018.4.
- [19] Bill Fefferman and Zachary Remscrim. Eliminating intermediate measurements in space-bounded quantum computation. In Proceedings of the 53rd Annual ACM SIGACT Symposium on Theory of Computing, pages 1343–1356, 2021. arXiv:2006.03530. doi:10.1145/3406325.3451051.
- [20] Lance Fortnow and Carsten Lund. Interactive proof systems and alternating time—space complexity. Theoretical Computer Science, 113(1):55–73, 1993. Preliminary Version in STACS 1991. doi:10.1016/0304-3975(93)90210-K.
- [21] Lance J. Fortnow. Complexity-Theoretic Aspects of Interactive Proof Systems. PhD thesis, Massachusetts Institute of Technology, 1989. URL: https://lance.fortnow.com/papers/files/thesis.pdf.
- [22] Pierre Fraigniaud, Ami Paz, François Le Gall, and Harumichi Nishimura. Distributed quantum proofs for replicated data. In Proceedings of the 12th Innovations in Theoretical Computer Science Conference, volume 185 of LIPIcs, pages 28:1–28:20, 2021. arXiv:2002.10018. doi:10.4230/LIPIcs.ITCS.2021.28.
- [23] Bernd Gärtner and Jiří Matoušek. Approximation Algorithms and Semidefinite Programming. Springer Berlin Heidelberg, 1st edition, 2012. doi:10.1007/978-3-642-22015-9_2.
- [24] Sevag Gharibian and Dorian Rudolph. Quantum space, ground space traversal, and how to embed multi-prover interactive proofs into unentanglement. In Proceedings of the 14th Innovations in Theoretical Computer Science, volume 251 of LIPIcs, pages 53:1–53:23, 2023. arXiv:2206.05243. doi:10.4230/LIPICS.ITCS.2023.53.
- [25] Uma Girish and Ran Raz. Eliminating intermediate measurements using pseudorandom generators. In Proceedings of the 13th Innovations in Theoretical Computer Science Conference, volume 215 of LIPIcs, pages 76:1–76:18, 2022. arXiv:2106.11877. doi:10.4230/LIPIcs.ITCS.2022.76.
- [26] Uma Girish, Ran Raz, and Wei Zhan. Quantum logspace algorithm for powering matrices with bounded norm. In Proceedings of the 48th International Colloquium on Automata, Languages, and Programming, volume 198 of LIPIcs, pages 73:1–73:20, 2021. arXiv:2006.04880. doi:10.4230/LIPIcs.ICALP.2021.73.
- [27] Uma Girish, Ran Raz, and Wei Zhan. Quantum logspace computations are verifiable. In Proceedings of the 2024 Symposium on Simplicity in Algorithms, pages 144–150, 2024. arXiv:2307.11083. doi:10.1137/1.9781611977936.14.
- [28] Shafi Goldwasser, Yael Tauman Kalai, and Guy N. Rothblum. Delegating computation: interactive proofs for muggles. Journal of the ACM (JACM), 62(4):1–64, 2015. Preliminary Version in STOC 2008. ECCC:TR17-108. doi:10.1145/2699436.
- [29] Shafi Goldwasser, Silvio Micali, and Charles Rackoff. The knowledge complexity of interactive proof systems. SIAM Journal on Computing, 18(1):186–208, 1989. Preliminary Version in STOC 1985. doi:10.1137/0218012.
- [30] Shafi Goldwasser and Michael Sipser. Private coins versus public coins in interactive proof systems. In Proceedings of the 18th Annual ACM Symposium on Theory of Computing, pages 59–68, 1986. doi:10.1145/12130.12137.
- [31] Atsuya Hasegawa, Srijita Kundu, and Harumichi Nishimura. On the power of quantum distributed proofs. In Proceedings of the 43rd ACM Symposium on Principles of Distributed Computing, pages 220–230, 2024. arXiv:2403.14108. doi:10.1145/3662158.3662788.
- [32] Sandy Irani, Anand Natarajan, Chinmay Nirkhe, Sujit Rao, and Henry Yuen. Quantum search-to-decision reductions and the state synthesis problem. In Proceedings of the 37th Computational Complexity Conference, pages 1–19, 2022. arXiv:2111.02999. doi:10.4230/LIPIcs.CCC.2022.5.
- [33] Tsuyoshi Ito, Hirotada Kobayashi, and John Watrous. Quantum interactive proofs with weak error bounds. In Proceedings of the 3rd Innovations in Theoretical Computer Science Conference, pages 266–275, 2012. arXiv:1012.4427. doi:10.1145/2090236.2090259.
- [34] Tsuyoshi Ito and Thomas Vidick. A multi-prover interactive proof for sound against entangled provers. In 53rd Annual IEEE Symposium on Foundations of Computer Science, FOCS 2012, New Brunswick, NJ, USA, October 20-23, 2012, pages 243–252. IEEE Computer Society, 2012. arXiv:1207.0550. doi:10.1109/FOCS.2012.11.
- [35] Rahul Jain, Zhengfeng Ji, Sarvagya Upadhyay, and John Watrous. . Journal of the ACM, 58(6):1–27, 2011. Preliminary Version in STOC 2010. arXiv:0907.4737. doi:10.1145/2049697.2049704.
- [36] Julia Kempe, Hirotada Kobayashi, Keiji Matsumoto, and Thomas Vidick. Using entanglement in quantum multi-prover interactive proofs. Computational Complexity, 18:273–307, 2009. Preliminary Version in CCC 2008. arXiv:0711.3715. doi:10.1007/s00037-009-0275-3.
- [37] Alexei Kitaev and John Watrous. Parallelization, amplification, and exponential time simulation of quantum interactive proof systems. In Proceedings of the 32nd Annual ACM Symposium on Theory of Computing, pages 608–617, 2000. doi:10.1145/335305.335387.
- [38] Alexei Y. Kitaev, Alexander H. Shen, and Mikhail N. Vyalyi. Classical and Quantum Computation, volume 47 of Graduate Studies in Mathematics. American Mathematical Society, 1st edition, 2002. doi:10.1090/gsm/047/10.
- [39] Hirotada Kobayashi, François Le Gall, and Harumichi Nishimura. Generalized quantum Arthur–Merlin games. SIAM Journal on Computing, 48(3):865–902, 2019. Preliminary Version in CCC 2015. arXiv:1312.4673. doi:10.1137/17M1160173.
- [40] Gillat Kol, Rotem Oshman, and Raghuvansh R Saxena. Interactive distributed proofs. In Proceedings of the 37th ACM Symposium on Principles of Distributed Computing, pages 255–264, 2018. doi:10.1145/3212734.3212771.
- [41] François Le Gall, Yupan Liu, Harumichi Nishimura, and Qisheng Wang. Space-bounded quantum interactive proof systems. arXiv preprint arXiv:2410.23958v3, 2024. arXiv:2410.23958v3. doi:10.48550/arXiv.2410.23958.
- [42] François Le Gall, Yupan Liu, and Qisheng Wang. Space-bounded quantum state testing via space-efficient quantum singular value transformation. arXiv preprint arXiv:2308.05079, 2023. arXiv:2308.05079. doi:10.48550/arXiv.2308.05079.
- [43] François Le Gall, Masayuki Miyamoto, and Harumichi Nishimura. Distributed quantum interactive proofs. In Proceedings of the 40th International Symposium on Theoretical Aspects of Computer Science, volume 254 of LIPIcs, pages 42:1–42:21, 2023. arXiv:2210.01390. doi:10.4230/LIPIcs.STACS.2023.42.
- [44] Richard J. Lipton. Efficient checking of computations. In Proceedings of the 7th Annual Symposium on Theoretical Aspects of Computer Science, volume 415 of Lecture Notes in Computer Science, pages 207–215. Springer, 1990. doi:10.1007/3-540-52282-4_44.
- [45] Alex Lombardi, Fermi Ma, and John Wright. A one-query lower bound for unitary synthesis and breaking quantum cryptography. In Proceedings of the 56th Annual ACM Symposium on Theory of Computing, pages 979–990, 2024. arXiv:2310.08870. doi:10.1145/3618260.3649650.
- [46] Carsten Lund, Lance Fortnow, Howard Karloff, and Noam Nisan. Algebraic methods for interactive proof systems. Journal of the ACM, 39(4):859–868, 1992. Preliminary Version in FOCS 1990. doi:10.1145/146585.146605.
- [47] Chris Marriott and John Watrous. Quantum Arthur–Merlin games. Computational Complexity, 14(2):122–152, 2005. Preliminary Version in CCC 2004. arXiv:cs/0506068. doi:10.1007/s00037-005-0194-x.
- [48] Tony Metger and Henry Yuen. . In Proceedings of the 64th Annual IEEE Symposium on Foundations of Computer Science, pages 1349–1356. IEEE, 2023. arXiv:2301.07730. doi:10.1109/FOCS57990.2023.00082.
- [49] Moni Naor, Merav Parter, and Eylon Yogev. The power of distributed verifiers in interactive proofs. In Proceedings of the 31st Annual ACM-SIAM Symposium on Discrete Algorithms, pages 1096–115. SIAM, 2020. arXiv:1812.10917. doi:10.1137/1.9781611975994.67.
- [50] Michael A. Nielsen and Isaac L. Chuang. Quantum Computation and Quantum Information. Cambridge university press, 10th anniversary edition, 2010. doi:10.1017/CBO9780511976667.
- [51] Harumichi Nishimura and Tomoyuki Yamakami. An application of quantum finite automata to interactive proof systems. Journal of Computer and System Sciences, 75(4):255–269, 2009. Preliminary Version in CIAA 2004. arXiv:quant-ph/0410040. doi:10.1016/j.jcss.2008.12.001.
- [52] Harumichi Nishimura and Tomoyuki Yamakami. Interactive proofs with quantum finite automata. Theoretical Computer Science, 568:1–18, 2015. arXiv:1401.2929. doi:10.1016/j.tcs.2014.11.030.
- [53] Attila Pereszlényi. On quantum interactive proofs with short messages. Chicago Journal of Theoretical Computer Science, 2012(9):1–10, 2012. arXiv:1109.0964. doi:10.4086/cjtcs.2012.009.
- [54] Gregory Rosenthal. Efficient quantum state synthesis with one query. In Proceedings of the 2024 Annual ACM-SIAM Symposium on Discrete Algorithms, pages 2508–2534, 2024. arXiv:2306.01723. doi:10.1137/1.9781611977912.89.
- [55] Gregory Rosenthal and Henry Yuen. Interactive proofs for synthesizing quantum states and unitaries. In Proceedings of the 13th Innovations in Theoretical Computer Science Conference, volume 215, pages 112:1–112:4, 2022. arXiv:2108.07192. doi:10.4230/LIPIcs.ITCS.2022.112.
- [56] Adi Shamir. . Journal of the ACM, 39(4):869–877, 1992. Preliminary Version in FOCS 1990. doi:10.1145/146585.146609.
- [57] Amnon Ta-Shma. Inverting well conditioned matrices in quantum logspace. In Proceedings of the forty-fifth annual ACM symposium on Theory of computing, pages 881–890, 2013. doi:10.1145/2488608.2488720.
- [58] Salil P Vadhan. A study of statistical zero-knowledge proofs. PhD thesis, Massachusetts Institute of Technology, 1999. URL: http://hdl.handle.net/1721.1/85349.
- [59] Hari Venkateswaran. Properties that characterize . Journal of Computer and System Sciences, 43(2):380–404, 1991. Preliminary Version in STOC 1987. doi:10.1016/0022-0000(91)90020-6.
- [60] Thomas Vidick and John Watrous. Quantum proofs. Foundations and Trends® in Theoretical Computer Science, 11(1-2):1–215, 2016. arXiv:1610.01664. doi:10.1561/0400000068.
- [61] John Watrous. Space-bounded quantum complexity. Journal of Computer and System Sciences, 59(2):281–326, 1999. Preliminary Version in CCC 1998. doi:10.1006/jcss.1999.1655.
- [62] John Watrous. Limits on the power of quantum statistical zero-knowledge. In Proceedings of the 43rd Annual IEEE Symposium on Foundations of Computer Science, pages 459–468, 2002. arXiv:quant-ph/0202111. doi:10.1109/SFCS.2002.1181970.
- [63] John Watrous. has constant-round quantum interactive proof systems. Theoretical Computer Science, 292(3):575–588, 2003. Preliminary Version in FOCS 1999. arXiv:cs/9901015. doi:10.1016/S0304-3975(01)00375-9.
- [64] John Watrous. On the complexity of simulating space-bounded quantum computations. Computational Complexity, 12:48–84, 2003. Preliminary Version in FOCS 1999. arXiv:cs/9911008. doi:10.1007/s00037-003-0177-8.
- [65] John Watrous. Zero-knowledge against quantum attacks. SIAM Journal on Computing, 39(1):25–58, 2009. Preliminary Version in STOC 2006. arXiv:quant-ph/0511020. doi:10.1137/060670997.
- [66] John Watrous. Semidefinite programs for interactive proofs (Tutorial at the 19th Conference on Quantum Information Processing, QIP 2016). https://qipconference.org/2016/qip-sdp-handout.pdf, 2016. Accessed: 2024-09-18.
- [67] Abuzer Yakaryılmaz. Public qubits versus private coins. In Proceedings of Workshop on Quantum and Classical Complexity, pages 45–60, 2013. ECCC:TR12-130.
- [68] Mark Zhandry. The space-time cost of purifying quantum computations. In Proceedings of the 15th Innovations in Theoretical Computer Science Conference, volume 287 of LIPIcs, pages 102:1–102:22, 2024. arXiv:2401.07974. doi:10.4230/LIPIcs.ITCS.2024.102.
