QIP $ \subseteq $ AM(2QCFA)

TL;DR

This paper demonstrates that the class PSPACE, including quantum interactive proof systems, can be contained within Arthur-Merlin systems with two-way finite automata equipped with quantum and classical states, using protocols with perfect completeness.

Contribution

It establishes that PSPACE and QIP are subsets of AM(2QCFA), introducing protocols with rational quantum transitions and perfect completeness, expanding the understanding of quantum automata capabilities.

Findings

PSPACE is contained in AM(2QCFA)

Protocols use only rational-valued quantum transitions

Achieve perfect completeness with double-exponential expected time

Abstract

The class of languages having polynomial-time classical or quantum interactive proof systems ($\mathsf{IP}$ or $\mathsf{QIP}$, respectively) is identical to $\mathsf{PSPACE}$. We show that $\mathsf{PSPACE}$ (and so $\mathsf{QIP}$) is subset of $\mathsf{AM(2QCFA)}$, the class of languages having Arthur-Merlin proof systems where the verifiers are two-way finite automata with quantum and classical states (2QCFAs) communicating with the provers classically. Our protocols use only rational-valued quantum transitions and run in double-exponential expected time. Moreover, the member strings are accepted with probability 1 (i.e., perfect-completeness).

Equations

$$\sum _{j=1}^k{E}_j^{†}{E}_j=I.$$

$$\begin{array}[]{|c|}\hline\cr E_{1}\\ \hline\cr E_{2}\\ \hline\cr\vdots\\ \hline\cr E_{k}\\ \hline\cr\end{array}\leavevmode\nobreak\ .$$

$$\{\widetilde{|v_1⟩},\dots ,\widetilde{|v_k⟩}\},$$

$$\left\{(p_1,|v_1⟩),\dots ,(p_k,|v_k⟩)\right\}.$$

$$\rho =\sum _{j=1}^k{p}_j|v_j⟩⟨v_j|=\sum _{j=1}^k\widetilde{|v_j⟩}\widetilde{⟨v_j|}.$$

$$V=(S,Q,\Sigma ,{\rm Y},\delta ,s_I,q_I,s_{acc},s_{rej}),$$

$$\dfrac{1}{D}\leavevmode\nobreak\ \begin{array}[]{|c|}\hline\cr M_{1}\\ \hline\cr M_{2}\\ \hline\cr M_{3}\\ \hline\cr\vdots\\ \hline\cr M_{k}\\ \hline\cr\end{array}=\mathcal{E}=\begin{array}[]{|c|}\hline\cr E_{1}\\ \hline\cr E_{2}\\ \hline\cr E_{3}\\ \hline\cr\vdots\\ \hline\cr E_{k}\\ \hline\cr\end{array},$$

$$\begin{array}[]{|c|}\hline\cr M_{1}\\ \hline\cr M_{2}\\ \hline\cr\end{array},$$

$$v_{0}=\left(\begin{array}[]{c}1\\ 0\end{array}\right).$$

$$A_{0}=\left(\begin{array}[]{cc}1&0\\ 0&2\end{array}\right)\leavevmode\nobreak\ \leavevmode\nobreak\ \mbox{and}\leavevmode\nobreak\ \leavevmode\nobreak\ A_{1}=\left(\begin{array}[]{cc}1&0\\ 1&2\end{array}\right).$$

$$v_{1}=A_{0}\cdot v_{0}=\left(\begin{array}[]{cc}1&0\\ 0&2\end{array}\right)\left(\begin{array}[]{c}1\\ 0\end{array}\right)=\left(\begin{array}[]{c}1\\ 0\end{array}\right)=\left(\begin{array}[]{c}1\\ \mathsf{val}(0)\end{array}\right)$$

$$v_{1}=A_{1}\cdot v_{0}=\left(\begin{array}[]{cc}1&0\\ 1&2\end{array}\right)\left(\begin{array}[]{c}1\\ 0\end{array}\right)=\left(\begin{array}[]{c}1\\ 1\end{array}\right)=\left(\begin{array}[]{c}1\\ \mathsf{val}(1)\end{array}\right).$$

$$v_{i}=\left(\begin{array}[]{c}1\\ \mathsf{val}(b)\end{array}\right).$$

$$v_{i+1}=A_{0}v_{i}=\left(\begin{array}[]{cc}1&0\\ 0&2\end{array}\right)\left(\begin{array}[]{c}1\\ \mathsf{val}(b)\end{array}\right)=\left(\begin{array}[]{c}1\\ 2\cdot\mathsf{val}(b)\end{array}\right)=\left(\begin{array}[]{c}1\\ \mathsf{val}(b0)\end{array}\right)$$

$$v_{i+1}=A_{1}v_{i}=\left(\begin{array}[]{cc}1&0\\ 1&2\end{array}\right)\left(\begin{array}[]{c}1\\ \mathsf{val}(b)\end{array}\right)=\left(\begin{array}[]{c}1\\ 2\cdot\mathsf{val}(b)+1\end{array}\right)=\left(\begin{array}[]{c}1\\ \mathsf{val}(b1)\end{array}\right).$$

$$A_{k}=\left(\begin{array}[]{cc}1&0\\ k&m\end{array}\right).$$

$$E_0=\frac{1}{\sqrt{2}}I\text{leavevmode}\text{leavevmode}\text{mbox}and\text{leavevmode}\text{leavevmode}{E}_1=\frac{1}{\sqrt{2}}I,$$

$$\underset{D^2\text{leavevmode}\text{mbox}times}{\underbrace{\frac{1}{D}I,\dots ,\frac{1}{D}}}I.$$

$$\mathtt{KNAPSACK}\text{mbox}-\mathtt{GAME}=\{S\text{leavevmode}\forall (a_1,b_1)\exists (e_1,f_1)\cdots \forall (a_n,b_n)\exists (e_n,f_n)\},$$

$$N_{\mbox{\textcent}}\left(\begin{array}[]{c}1\\ 0\\ 0\\ 1\end{array}\right)$$

$$N_{0}\left(\begin{array}[]{c}1\\ \mathsf{val}(S)\\ 0\\ 1\end{array}\right),$$

$$N_{1}\left(\begin{array}[]{c}1\\ val(S)-x_{1}-y_{1}\\ 0\\ 1/4\end{array}\right),$$

$$N_{2}\left(\begin{array}[]{c}1\\ val(S)-x_{1}-y_{1}-x_{2}-y_{2}\\ 0\\ (1/4)^{2}\end{array}\right),$$

$$T=(x_1+y_1)+(x_2+y_2)+\cdots +(x_n+y_n).$$

$$N_{n}\left(\begin{array}[]{c}1\\ S-T\\ 0\\ (1/4)^{n}\end{array}\right),$$

$$|v_{acc}\rangle=N_{\$}\left(\begin{array}[]{c}0\\ 0\\ 0\\ (1/4)^{n}\end{array}\right)\leavevmode\nobreak\ \leavevmode\nobreak\ \mbox{and}\leavevmode\nobreak\ \leavevmode\nobreak\ |v_{rej}\rangle=N_{\$}\left(\begin{array}[]{c}0\\ S-T\\ 0\\ 0\end{array}\right),$$

$$N_{\$}={\left(\frac{1}{D}\right)}^l,$$

$$S=T$$

$$N_{\$}^2{\left(\frac{1}{16}\right)}^n.$$

Full text

1 Introduction

Proof systems play a central role in classical and quantum complexity theory [1, 2]. In polynomial time computation, interactive proof systems (IPSs) [3, 4], Arthur-Merlin (AM) proof systems [5], and quantum interactive proof systems [6] have the same verification power, i.e., they can verify all and only languages in $\mathsf{PSPACE}$.

In constant-space, IPSs with two-way probabilistic finite state automaton (2PFA) verifiers can verify any language in $\mathsf{ASPACE(n)}$ (i.e., alternating linear space) [7]. On the other hand, AM systems with 2PFA verifiers are much weaker: any language verified by them is in $\mathsf{P}$, and they cannot verify some languages in $\mathsf{L}$ such as $\mathtt{PAL}=\{w\in\{a,b\}^{*}|w=w^{reverse}\}$ [8, 7].

More than a decade ago, Yakaryılmaz introduced and investigated AM system where the verifier is a two-way automaton with quantum and classical states (2QCFA) [9, 10]. We denote $\mathsf{AM_{1}(2QCFA})$ as the class of the languages verified by these systems with perfect-completeness (i.e., member strings are accepted by the verifier with probability 1). Yakaryılmaz showed that $\mathsf{AM_{1}(2QCFA})$ contains $\mathsf{NP}$, $\mathsf{ASPACE(n)}$, and an $\mathsf{NEXP}$-complete problem. In this paper, we show that $\mathsf{AM_{1}(2QCFA})$ also contains $\mathsf{PSPACE}$. We use similar techniques given in [9, 10].

We give the definitions and notations used throughout the paper in Section 2. Then, we present several technical details used in our proofs in Section 3. After that, we present a protocol for a $\mathsf{PSPACE}$-complete language $\mathtt{KNAPSACK\mbox{-}GAME}$ in Section 4. We follow our main result in Section 5. We close the paper with Section 6.

We assume the reader is familiar with proof systems, quantum computing, and automata theory. For background on classical and quantum proof systems, we refer to [1, 2]; for a comprehensive review of quantum automata, see [11, 12]; and for further details on AM systems with the verifiers using constant-size quantum memory, see [9, 10].

2 Preliminaries

Two-way finite automaton with quantum and classical states (2QCFA) is a classically controlled automaton accessing a finite-size quantum register [13]. A 2QCFA can apply unitary or measurement operators to its quantum register, and it can also process any onserved measurement outcome. It is also known as two-way quantum finite automaton with classical head [14]. Here, we define 2QCFAs with superoperators (easily simulated by unitary operators and projective measurements with the help of classical states, e.g., [14]) to shorten our quantum programs and to use only rational transition values.

A superoperator $\mathcal{E}$ is composed by $k$ operational elements $\{E_{1},\ldots,E_{k}\}$ for some $k>0$ satisfying that

[TABLE]

Equivalently, the columns of the following matrix form an orthonormal set

[TABLE]

If $k=1$, then it is a unitary operator. Any measurement operator can also be a represented as a superoperator, where the operator indices are associated with the measurement outcomes.

After applying $\mathcal{E}$ to the quantum state $|v\rangle$, denoted $\mathcal{E}(|v\rangle)$, we obtain the following unnormalized state vectors:

[TABLE]

where $\widetilde{|v_{j}\rangle}=E_{j}|v\rangle$. Here the outcome $j$ can be observed with probability $p_{j}=\langle v_{j}|v_{j}\rangle$, and so $\widetilde{|v_{j}\rangle}$ is normalized as $|v_{j}\rangle=\frac{\widetilde{|v_{j}\rangle}}{\sqrt{p_{j}}}$ (if $p_{j}>0$). Thus, the mixture obtained by $\mathcal{E}(|v\rangle)$ is represented as

[TABLE]

This mixture can be represented as a single mathematical object called density matrix:

[TABLE]

In this paper, though we use superoperators with several operational elements, we keep our “useful” computation in one of the pure states after each operation and discard the rest of pure states. Thus, the density matrix is not used.

Arthur-Merlin (AM) proof systems are known as public-coin IPSs, as the computation of verifiers are visible to the provers. A 2QCFA verifier is formally a 8-tuple

[TABLE]

where

• •

$S$ is a finite set of classical states, formed by two disjoint sets, $S_{c}$ and $S_{r}$ containing the communication and reading states, respectively;

• •

$Q$ is a finite set of quantum states;

• •

$\Sigma$ is the input alphabet not containing the left and right en-markers (¢ and $$$, respectively);

• •

$\Upsilon$ is the communication alphabet;

• •

$\delta$ is the transition function, formed by $\delta_{c}$, $\delta_{r}$, and $\delta_{q}$ responsible for communication, classical control, and quantum transitions, respectively;

• •

$s_{I}\in S$ is the starting state; and,

• •

$s_{acc},s_{rej}\in S$ are the accepting and rejecting states, respectively.

A given input $w\in\Sigma^{*}$ is placed on a read-only input tape between two end-makers as \mbox{\textcent}w\$$. The verifier V$starts in states$(s_{I},|q_{I}\rangle)$, and the input head is placed on ¢.

The verifier $V$ communicates with a prover through a communication channel storing one symbol from $\Upsilon$ or a measurement outcome (i.e., the index of the corresponding operation element) of superoperators. When in a communication state, say $s_{c}$, $V$ writes a symbol on the communication channel, and then the prover overwrites it with their respond, say $\upsilon$. After that $V$ updates its state as $s^{\prime}$, where $\delta_{c}(s_{c},\upsilon)=s^{\prime}$.

When in a reading state, say $s_{r}$, and scanning an input symbol, say $\sigma$, $V$ makes two transitions. First, a superoperator is determined by $\delta_{q}(s_{r},\sigma)=\mathcal{E}$, and it is applied to the quantum register. The measurement outcome, say $j$, is written on the communication channel to be shared with the prover. Second, $V$ updates its state and head position based on the current classical state, scanning input symbol, and the measurement outcome: $\delta_{r}(s_{r},\sigma,j)=(s^{\prime},d)$, where $s^{\prime}$ is the new classical state; and the input head moves one symbol to the left (right), if $d=-1$ ($d=1$), and, the input head does not move if $d=0$. It must be guaranteed that the input head never leaves $\mbox{\textcent}w$$ on the tape.

The input $w$ is accepted if $V$ enters $s_{acc}$, and it is rejected if $V$ enters $s_{rej}$. In either case, the computation is terminated.

A language $L\subseteq\Sigma^{*}$ is said to be verified by $V$ with error bound $\epsilon\in[0,\frac{1}{2})$ if and only if

when $w\in L$, $V$ communicates with an honest prover $P$ and accepts $w$ with probability at least $1-\epsilon$, and, 2. 2.

when $w\notin L$, $V$ rejects $w$ with probability at least $1-\epsilon$ by communicating with any possible prover $P^{*}$ (including cheating ones).

It is also said that $L$ is verified by $V$ with bounded error. If every member is accepted with probability 1, then it is said that $L$ is verified with perfect-completeness.

The class $\mathsf{AM(2QCFA)}$ is the set of languages verified by 2QCFAs with bounded error, and the class $\mathsf{AM_{1}(2QCFA)}$ is the set of languages verified by 2QCFAs with perfect-completeness. Here we assume that the entries of superoperators are formed by rational numbers. (With arbitrary real-valued transitions, for example, 2QCFAs can verify every language [15].) These classes may also be defined with algebraic or efficiently computable numbers (see [16, 17]).

3 Technical details

3.1 Rational-valued superoperators

We do our calculations with rational-valued or integer matrices throughout the paper. More specifically, we solve certain tasks with these matrices and then embed them into some superoperators.

Our generic technique is as follows. Suppose that we use two rational-valued matrices $M_{1}$ and $M_{2}$. They form our main operation elements after dividing by some integers. Then, we define as many as auxiliary operation elements to have a superoperator:

[TABLE]

where $1/D$ is the normalization factor, $E_{1}$ and $E_{2}$ are the main operation elements, and $E_{3},\ldots,E_{k}$ are auxiliary operation elements for some $k>1$. The value of $D$ and the entries are $M_{3},\ldots,M_{k}$ are determined to ensure that $\mathcal{E}$ is a superoperator. The columns of

[TABLE]

may not be orthogonal or may not have the same length. Step by step, by adding the entries below (as the entries of $M_{3}$, $M_{4}$, …) we can make the columns are pair-wise orthogonal and then by adding further entries to make the lengths are equal. We refer the reader to [14] for the details.

We always pick $D$ as some positive integers. If we have several superoperators with different $D$ values, we add more auxiliary operation elements to ensure that all has the same $D$.

3.2 Encoding binary numbers

We present encoding of binary numbers by using two-dimensional vectors. We start in

[TABLE]

When reading symbols [math] and $1$, we multiply it with the following matrices:

[TABLE]

The first entry does not change, and the binary values are encoded on the second entry. We show the correctness of this method by induction.

Let $b$ be a binary number and $\mathsf{val}(b)$ be its value. We start with trivial cases when $b=0$ and $b=1$:

[TABLE]

and

[TABLE]

Suppose that $b$ with length $i>0$ is encoded as described. That is, we have

[TABLE]

Then, we read [math] or $1$:

[TABLE]

or

[TABLE]

As easy to see, $b0$ and $b1$ are encoded correctly.

3.3 Encoding $m$-ary numbers

This is a generalization of the previous subsection. We use $m$ digits for $m$-ary numbers: $\{0,1,\ldots,m-1\}$. When reading $k$ among them, we use the following encoding matrix:

[TABLE]

The rest is the same.

3.4 Coin-flip

For a given quantum register, we can use the following superoperator with two operational elements to simulate a fair coin-flip:

[TABLE]

where $I$ is the identity matrix. Thus, we can observe the outcomes 0 and 1 with equal probability while the quantum state does not change.

To be consistent with the framework given in Sec. 3.1, we can use a superoperator with $D^{2}$ operational elements:

[TABLE]

Here we can pick any two of them as the main operational elements.

3.5 Superoperator for the identity operator

To have a well-tuned normalization factor in our protocols, we may use the the following superoperator instead of the identity operator:

[TABLE]

Here we can pick one of them as the main operational element.

3.6 Encoding the configurations of a Turing machine

Here we explain how to encode the configurations of a single-tape single-head Turing Machine (TM), say $M$, on any given input, say $w$. The tape is two-way infinite indexed by the integers. Any given input $w$ is placed from the left to the right on the tape starting from the tape cell indexed by 1. The rest of cells contain $\#$ symbols at the beginning of the computation. Any configuration of $M$ in any step is of the form $xsy$, where $s$ is the state of $M$, $xy$ is the significant piece of the tape content obtained by removing all insignificant blank symbols except the ones on the left and right, and the tape head is situated on the left-most symbol of $y$. The initial configuration is $s_{I}\#w\#$, where $s_{I}$ is the initial state. When in state $s$ and reads symbol $\sigma$, $M$ updates its state with $s^{\prime}$, overwrites the symbol under the head with $\sigma^{\prime}$, and updates the head position by at most one cell based on its transition rule $(s,\sigma)\rightarrow(s^{\prime},\sigma^{\prime},d)$, where $d\in\{-1,0\,1\}$ represents of the head moves to the left, stays stationary, or moves to the right, respectively.

As the tape head can move at most one cell in a single transition, the length of a configuration can be changed by at most 1. Here are two representative examples:

• •

We implement the transition $(s,\#)\rightarrow(s^{\prime},\#,-1)$ when in the configuration $s\#001\#$. Thus, the new configuration becomes $s^{\prime}\#\#001\#$. The blank symbol under the head is overwritten with itself, and then the head is moved one cell to the left. The length of configuration is increased by 1.

• •

We implement the transition $(s,1)\rightarrow(s^{\prime},\#,-1)$ when in the configuration $\#10s1\#$. Thus, the new configuration is $\#1s^{\prime}0\#$. The symbol $1$ under the head is overwritten with the blank symbol, and then the head is moved one cell to the left. The length of configuration is decreased by 1.

Moreover, in a single transition, at most three consecutive symbols of a configuration can be changed:

• •

The symbol next to the state can be changed.

• •

The state itself can be changed.

• •

The new state can be swapped with the symbol next to it or before it.

Each configuration is represented by a $m$-ary string for some $m>0$, and so, we can encode their values in base-$m$. Here $m$ is the size of the configuration alphabet formed by the tape alphabet and the set of states. Each symbol in the configuration alphabet is associate by a number in $\{0,1,\ldots,m-1\}$, where $\#$ is never associated with 0. Thus, none of the configurations represented in base-$m$ starts with 0.

We can encode each configuration by using the integer matrices given in Sec. 3.3. While reading a configuration from left to right, we can also easily output the valid successor configuration. By reading the first three symbols, we can output the first symbol of the (valid) successor configuration. After that, for each symbol of the configuration, we can output a new symbol of the successor configuration. After reading the whole configuration, we use up to three more steps to complete outputting the successor configuration. While outputting the successor configuration, we can also encode its value in the same way of encoding the value of scanning configuration.

4 Knapsack game

We give the definition of a Knapsack game shown to be PSPACE-complete under log-space reduction [18, 19, 20]:

[TABLE]

where

• •

$S$ and each $a_{i},b_{i},e_{i}$, and $f_{i}$ are natural numbers given in binary ($1\leq i\leq n$); and,

• •

for every $x=(x_{1},\ldots,x_{n})\in\times_{i=1}^{n}\{a_{i},b_{i}\}$, there exists a $y=(y_{1},\ldots,y_{n})\in\times_{i=1}^{n}\{e_{i},f_{i}\}$ such that $S=\sum_{i=1}^{n}=x_{i}+y_{i}$.

Theorem 1**.**

The language $\mathtt{KNAPSACK\mbox{-}GAME}$ can be verified by a 2QCFA with perfect-completeness in exponential expected time.

Proof.

At the beginning, the verifier reads the input once and deterministically checks if it is in the form of Eq. 2. If not, the input is rejected and computation is terminated.

In the remaining part, we assume that the input is in the form of Eq. 2. The verifier uses a quantum register with 4 states, $\{q_{1},q_{2},q_{3},q_{4}\}$.

The verifier executes an infinite loop. In each iteration, the verifier reads the input from the left to the right. For each symbol, it applies a superoperator. If the outcome is one of the main operational elements, the computation continues. Otherwise, the current iteration is terminated. Until reading the right end-marker, each superoperator has only a single main operation element. Thus, as long as the iteration is not terminated, the computation continues with a single pure state. In this way, with an exponentially small probability, the computation survives until the end, and then the verifier makes a decision.

Step 0. The quantum register starts in state $(1\leavevmode\nobreak\ \leavevmode\nobreak\ 0\leavevmode\nobreak\ \leavevmode\nobreak\ 0\leavevmode\nobreak\ \leavevmode\nobreak\ 0)^{T}$. By reading the left end-marker, the unnormalized quantum state is set to

[TABLE]

in the non-terminated part, where $N_{\mbox{\textcent}}$ is the normalization factor. Then the verifier reads $S$ and attempts to encode its value into the amplitude of $q_{2}$. If this encoding is successful, the unnormalized quantum state is

[TABLE]

where $N_{0}$ is the cumulative normalization factor so far. For encoding, we embed $A_{0}$ and $A_{1}$ given in Sec. 3.2 into the related main operation elements of superoperators.

Step 1. The verifier reads the first $\forall$ and then makes a fair coin-flip as described in the second part of Sec. 3.4. If the outcome is 0, then the verifier encodes the value of $a_{1}$. Otherwise, it encodes the value of $b_{1}$. In other words, the verifier picks $x_{1}\in\{a_{1},b_{1}\}$. Binary encoding technique is the same as in Step 0 but the verifier uses the amplitude of $q_{3}$ this time, i.e., the value of $x_{1}$ is encoded into the amplitude of $q_{3}$ with the help of the amplitude of $q_{1}$. Before reading the first $\exists$ symbol, the encoded value is subtracted from $S$ and the amplitude of $q_{3}$ is set to 0. Besides, the amplitude of $q_{4}$ is halved. To have a well-tuned normalization factor at the end, the verifier applies the superoperator described in Sec. 3.5 while reading any other symbol.

After that, the verifier requests from the prover one bit value: If the prover sends [math] (resp., $1$), the verifier encodes the value of $e_{1}$ (resp., $f_{1}$) into the amplitude of $q_{3}$. We represent the encoded value as $y_{1}\in\{e_{1},f_{1}\}$. After that, the value of $y_{1}$ is subtracted from $S$, and the amplitude of $q_{3}$ is set to 0 and the amplitude of $q_{4}$ is halved. As described above, to have a well-tuned normalization factor at the end, the verifier applies the superoperator described in Sec. 3.5 while reading any other symbol.

At this point, unless the iteration is terminated, the unnormalized quantum state, is

[TABLE]

where $N_{1}$ is the cumulative normalization factor so far.

Step 2. The verifier reads $\forall(a_{2},b_{2})\exists(e_{2},f_{2})$ and do the same as in Step 1. If $x_{2}\in\{a_{2},b_{2}\}$ is picked by the verifier and $y_{2}\in\{e_{2},f_{2}\}$ is picked by the prover, the unnormalized quantum state, unless the iteration is terminated, is

[TABLE]

where $N_{2}$ is the cumulative normalization factor so far.

Steps 3., 4., …, $\mathbf{n}$. We continue in the same way. Let $T$ be the summation of all chosen $x_{i}$s and $y_{i}$s:

[TABLE]

Thus, if the iteration has not been terminated until reading the right end-marker, the quantum state is

[TABLE]

where $N_{n}$ is the cumulative normalization factor so far.

Step $\mathbf{n+1}$. After reading \$$, the input is accepted based on the amplitude of q_{4}$, and it is rejected based on the amplitude of$q_{2}$. Otherwise, the verifier continues with the next iteration. For this, we obtain two unnormalized quantum states as

[TABLE]

where N_{\}$is an exponentially small value in the input length. If the verifier reads in total$l$ symbols (the input and end-markers) in one iteration, then indeed we have

[TABLE]

which is the same for every sequence of choices by the verifier and prover.

Decision. We start with the analysis of the accepting and rejecting probabilities of a single iteration. We have $2^{n}$ different universal choices. For each of them, the verifier provides existential choices.

If the input is a member string, we know that for each universal choices we have

[TABLE]

by communicating with an honest prover. That means the input is rejected with probability 0.

Each universal choice leads us to an acceptance condition and it is probability is

[TABLE]

Thus, the member strings are accepted with probability 1 (i.e., perfect-completeness) in exponential expected time.

If the input is not a member string, we know that in at least one of the universal choices, we have $S\neq T$. Then, we check the ratio of rejecting and accepting probabilities in a single iteration. If $S\neq T$, then $(S-T)^{2}$ can be at least 1. Then, this ratio cannot be less than

[TABLE]

where the acceptance probabilities come from all universal choices ($2^{n}$ in total). Thus, the non-member strings are rejected with probability at least

[TABLE]

This probability can increased by tuning the acceptance probability. The running time is again exponential in the input length. ∎

5 Simulating linear-space Turing machines

Fact 1**.**

[10]** Any language recognized by a linear-space DTM, say $M$, can be verified by a 2QCFA with perfect-completeness in double-exponential expected time.

Proof.

Let $k$ be an integer such that the length of any configuration of $M$ (as explained in Sec. 3.6) is at most $k\cdot n$ for every $n>0$, where $n$ is the length of input. We assume that the symbol $@$ is not in the configuration alphabet. For a given input $w$, a valid configuration history of $M$ on $w$ is

[TABLE]

where $c_{1}$ is the initial configuration, $c_{i}$ is the configuration obtained from $c_{i-1}$ in a single transition for $i>1$, and $c_{f}$ is the final configuration. Here we separate each configuration with four symbols, and we apply a superoperator for each.111One may indeed use less symbols here by combining some of superoperators appropriately.

The verifier runs an infinite loop and in each iteration requests a valid configuration history of $M$ on $w$. During an iteration, whenever an outcome associated to an axillary operation element is observed, it is terminated and a new iteration begins.

Deterministic checks. The verifier does certain deterministic checks in each iteration and rejects the input if any of them fails.

The verifier deterministically checks if the first configuration provided by the prover is $c_{1}$ by reading the input once from the left to the right. 2. 2.

The verifier uses its classical states to count the number of $@$ symbols and checks if it is equal to 4 in each block. 3. 3.

The verifier checks if the configuration history ends with a $$$ symbol. 4. 4.

The verifier checks if there is only one halting configuration and it is the last one. 5. 5.

The verifier ensures that the length of each configuration provided by the prover is at most $k\cdot|w|$ by using its input head and classical states: the verifier uses its input marked with the end-markers as a counter of length $|w|$, and then, easily count up to $k\cdot|w|$ by staying $k$ steps on each input symbol.

Thanks to these deterministic checks – in the remaining part, we assume that the prover sends a configuration history as

[TABLE]

Otherwise, the input is rejected by the verifier.

Quantum checks. The verifier checks the correctness of the configuration sequences provided by the prover. It uses a quantum register with four states: $\{q_{1},q_{2},q_{3},q_{4}\}$.

While scanning $c_{1}$, it encodes the value of the configuration obtained from $c_{1}$ in a single transition, namely $\mathsf{next}(c_{1})$, into the amplitude of $q_{4}$. When reading the forth $@$ symbol, $\mathsf{next}(c_{1})$ is transferred to the amplitude of $q_{2}$, and the amplitude of $q_{4}$ is set to 0.

Then, the verifier scans $c^{\prime}_{2}@@@@$. The value of $c^{\prime}_{2}$ is encoded into the amplitude of $q_{3}$, and $\mathsf{next}(c^{\prime}_{2})$ is encoded into the amplitude of $q_{4}$. The quantum state is as below just before reading the last $@$ symbol:

[TABLE]

where the $N_{2}$ is the normalization factor. The next superoperator has two main operational elements. The quantum state obtained by the first one is

[TABLE]

where $N^{\prime\prime}_{2}$ is the normalization factor. If this is observed, the input is rejected by the verifier. It is easy to see that this can be observed only if $\mathsf{next}(c_{1})\neq\mathsf{val}(c^{\prime}_{2})$, i.e., the prover cheats about $c^{\prime}_{2}$, which is different than $c_{2}$. This part is indeed how the verifier checks if the prover cheats about the configuration history. The quantum state obtained by the second operation element is

[TABLE]

where $N^{\prime}_{2}$ is the normalization factor. The iteration continues if this is observed.

When scanning $c^{\prime}_{3}@@@@$, the quantum state, just before reading the last $@$ symbol, is

[TABLE]

where the $N_{3}$ is the normalization factor. Again the superoperator has two main operational elements. The quantum state obtained by the first one is

[TABLE]

where $N^{\prime\prime}_{3}$ is the normalization factor. If this is observed, the input is rejected by the verifier. This can happen only if $\mathsf{next}(c^{\prime}_{2})\neq\mathsf{val}(c^{\prime}_{3})$. The quantum state by the second operation element is

[TABLE]

where $N^{\prime}_{3}$ is the normalization factor. The iteration continues if this is observed.

The verifier scans the rest of configurations provided by the prover in the same way.

After scanning $c^{\prime}_{f^{\prime}}@@@@$, the quantum state is

[TABLE]

where $N^{\prime}_{f^{\prime}}$ is the normalization factor. By scanning the \$$ symbol provided by the prover, the verifier makes its decision based on the halting configuration c^{\prime}_{f^{\prime}}$. If it is an accepting (resp., a rejecting) configuration, the verifier accepts (resp., rejects) the input. If the length of configuration history except$$$provided by the prover is$l$, then the probability of this decision is

[TABLE]

If there is any mismatch in the configuration history, i.e., $\mathsf{next}(c_{i})\neq\mathsf{val}(c_{i+1})$ for some $i$, the input is rejected with probability at least

[TABLE]

where $l^{\prime}\leq l$ is the number of symbols provided by the prover until that point.

If $w$ is in the language, the configuration history provided by an honest prover is valid. So, the input is never rejected but accepted with probability $\left(\frac{1}{D}\right)^{2l}$ in a single iteration. Thus, the input is accepted with probability 1.

If $w$ is not in the language, we have two cases. If the prover is honest, the input is never accepted but rejected with probability $\left(\frac{1}{D}\right)^{2l}$ in a single iteration. If the prover is cheating, then there must be a configuration mismatch. Thus, the rejecting probability in this iteration is at least 9 times more than any possible accepting probability due to Eq. 4 and Eq. 5. So, the overall rejecting probability is at least

[TABLE]

By using a coefficient greater than 3 in Eq. 3 (and in the other mismatch checks), we can obtain better rejecting probability.

The minimal halting probability is obtained when receiving a valid configuration history. That is,

[TABLE]

The value of $l$ can be bounded by $|w|\cdot 2^{O(|w|)}$, as the number of all possible configurations can be at most exponential in $|w|$ when using linear space. Thus, the expected running time is

[TABLE]

which is double-exponential in $|w|$. ∎

Fact 2**.**

[10]** Any language recognized by a linear-space NTM can be verified by a 2QCFA with perfect-completeness in double-exponential expected time.

Proof.

We adopt the proof given for linear-space DTMs. The nondeterministic choices are selected by the prover. Before receiving a configuration $c$ from the prover, the verifier asks for which nondeterministic choice is picked when in $c$. Based on the provided selection, the verifier prepares $\mathsf{next}(c)$ and compares it with the configuration provided by the prover immediately after $c$. The rest of the proof is the same.

For the member inputs, the honest prover sends a valid configuration history, and so, those inputs are accepted by the verifier with probability 1.

For the non-member inputs, the verifier can make the decision of “acceptance” only if an invalid configuration history is provided by the prover. Thus, the rejecting probability due to a mismatch is always sufficiently bigger than the any potential accepting probability as explained before. ∎

Theorem 2**.**

Any language $L$ linear-space reducible to $\mathtt{KNAPSACK\mbox{-}GAME}$ is verified by a 2QCFA verifier, say $V$, with perfect completeness. The protocol runs in double-exponential expected time.

Proof.

Let $M$ be a linear-space DTM reducing $L$ to $\mathtt{KNAPSACK\mbox{-}GAME}$. A reducer may have a read-only tape and a working tape separately, especially when focusing on sub-linear space (e.g., log-space) reductions. But, in our case, $M$ has a single read/write tape. A reducer uses a write-only output tape to write the output string. However, in our simulation below, we assume that $M$ does not have any output tape. We use the same configuration history format presented in the proof of Fact 1 for $M$. While it scans any configuration of $M$, the verifier knows the next symbol to be written on the output tape. To process this symbol, it uses its internal states to store it temporarily. We assume that once $M$ completes its computation, it enters an accepting state, which is the only halting state.

Our verifier $V$ executes the 2QCFA verifiers given in the proofs of Fact 1 and Theorem 1 in parallel. We name them $V_{1}$ and $V_{2}$, respectively.

• •

The verifier $V$ requests from the prover the valid configuration history of $M$ on the given input.

• •

The verifier $V_{1}$ ensures that the provided configuration sequence is valid or not.

• •

While reading every configuration, $V$ checks if $M$ outputs any symbol when in this configuration. If so, $V$ stores this symbol.

• •

Once a new symbol is stored by $V$, it is fed to $V_{2}$.

The quantum register of $V$ is combined by the quantum registers of $V_{1}$ and $V_{2}$. But, each sub-register works separately. So, we can see them as two separate quantum registers.

The input is accepted by $V$ if both $V_{1}$ and $V_{2}$ gives the decision of “acceptance”. Otherwise, the input is rejected by $V$. In this way, the perfect-completeness property is preserved.

Let $w$ be a given input, and let $u$ be the output string by $M$ when starting with $w$.

Member inputs ($w\in L$). By communicating with an honest prover, $V$ obtains $u$ symbol by symbol and then feed it to $V_{2}$. We know that $u$ is a member string of $\mathtt{KNAPSACK\mbox{-}GAME}$. As the computation history of $M$ is valid, $V_{1}$ only makes the decision of “acceptance”. Similarly, the honest prover provides valid nondeterministic choices to $V_{2}$ when processing $u$. Then, $V_{2}$ also only makes the decision of “acceptance”. Thus, $w$ is accepted by $V$ with probability 1.

Non-member inputs ($w\notin L$). For simplicity, we assume that $V$ communicates with two provers: $V_{1}$ communicates with $P_{1}$, and $V_{2}$ communicates with $P_{2}$. (There is a single prover, but in this way, we can separate the communications of $V_{1}$ and $V_{2}$ from each other.)

• •

If $P_{1}$ is honest, $V_{1}$ only accepts $w$, and $u\notin\mathtt{KNAPSACK\mbox{-}GAME}$ is fed to $V_{2}$. Then, we know that $V_{2}$ rejects $u$ with high probability independent of the honesty of $V_{2}$. Thus, $V$ rejects $w$ with high probability.

• •

If $P_{1}$ is not honest, then $V_{1}$ rejects $w$ with high probability. So, even if $V_{2}$ only accepts $u$, $V$ rejects $w$ with high probability.

The verifier $V_{1}$ runs in double-exponential expected time. The (expected) length of $u$ can be in exponential in $|w|$, and so, $V_{2}$ also runs in double-exponential expected time. Both $V_{1}$ and $V_{2}$ runs in parallel, so, $V$ runs in double-exponential expected time. ∎

Corollary 1**.**

Any language is PSPACE is verified by a 2QCFA verifier with perfect-completeness. The protocol runs in double-exponential time.

Proof.

This follows from the fact that any language in PSPACE is log-space reducible to $\mathtt{KNAPSACK\mbox{-}GAME}$. Remark that any log-space reduction can be exactly simulated by a linear-space reducer without using any extra work tape. ∎

6 Concluding Remarks

Arthur-Merlin (AM) systems with 2PFA verifiers are too weak when comparing with AM systems with 2QCFA verifiers. Comparing them with private-coin interactive proof systems (IPSs) with 2PFAs verifiers makes more sense. We observe that being in superposition makes the protocols stronger similar to private-coin protocols. In addition to that 2QCFAs benefit from interference (see [13, 21]).

It is open if IPSs with 2PFA verifiers can go beyond $\mathsf{ASPACE(n)}=\mathsf{DTIME\left(2^{O(n)}\right)}$ or if they can verify any language in $\mathsf{PSPACE}$ (or $\mathsf{NP}$). The class $\mathsf{AM_{1}(2QCFA)}$ already contains $\mathsf{ASPACE(n)}$, $\mathsf{PSPACE}=\mathsf{QIP}$, and an $\mathsf{NEXP}$-complete language. One may ask if $\mathsf{AM_{1}(2QCFA)}$ or $\mathsf{AM(2QCFA)}$ contains $\mathsf{EXP}$ or $\mathsf{NEXP}$ (or beyond). In such case, the verification power of 2QCFAs can be compared with polynomial-time multi-prover interactive proof systems.

Acknowledgments

Yakaryılmaz was partially supported by the Latvian Quantum Initiative under European Union Recovery and Resilience Facility project no. 2.3.1.1.i.0/1/22/I/CFLA/001