Zero-Error Affine, Unitary, and Probabilistic OBDDs

TL;DR

This paper introduces the affine OBDD model and demonstrates its exponential efficiency over traditional models in certain problems, along with quadratic improvements of Las Vegas models over deterministic ones.

Contribution

It presents the affine OBDD model and compares its width to unitary, probabilistic, and deterministic OBDDs, revealing exponential and quadratic separations.

Findings

Zero-error affine OBDDs can be exponentially narrower.

Las Vegas unitary and probabilistic OBDDs can be quadratically narrower.

Results hold for automata versions of these models.

Abstract

We introduce the affine OBDD model and show that zero-error affine OBDDs can be exponentially narrower than bounded-error unitary and probabilistic OBDDs on certain problems. Moreover, we show that Las Vegas unitary and probabilistic OBDDs can be quadratically narrower than deterministic OBDDs. We also obtain the same results by considering the automata versions of these models.

Equations

$$f_{P_n}(x)=\sum _{s_i\in S_a}{v}_f[i].$$

$$v=\left(\begin{array}[]{c}\alpha_{1}\\ \alpha_{2}\\ \vdots\\ \alpha_{m}\end{array}\right)\in\mathbb{R}^{m}$$

$$f_{M_n}(x)=\sum _{e_i\in E_a}\frac{|v_f[i]|}{|v_f|}.$$

$$\left(\begin{array}[]{c|c}\begin{array}[]{c|c|c}0&-1~{}~{}\cdots~{}~{}-1&0\\ \hline\cr 0&&0\\ \vdots&\mathbf{I_{(i-1)\times(i-1)}}&\vdots\\ 0&&0\\ \hline\cr 1&1~{}~{}~{}~{}\cdots~{}~{}~{}~{}1&1\end{array}&~{}~{}~{}~{}\mathbf{0}{}{}{}{}\\ \hline\cr\\ \mathbf{0}&\mathbf{I}\\ \\ \end{array}\right),$$

$$\begin{array}[]{cc}&p_{0}\times S~{}~{}~{}~{}p_{1}\times S\\ \begin{array}[]{c}p_{0}\times S\\ p_{1}\times S\end{array}&\begin{array}[]{c}\left(\begin{array}[]{c|c}~{}~{}~{}~{}~{}0{}{}{}{}{}&~{}~{}~{}~{}~{}R{}{}{}{}{}\\ \hline\cr I&0\end{array}\right)\end{array}\end{array},$$

$$\underset{i\in \{1,\dots ,|w|\},(|w|-i)\mathrm{mod}2k=j}{⨁}{w}_i=a_j.$$

Full text

Keywords: OBDDs, affine models, quantum and probabilistic computation, zero-error, Las Vegas automata

1 Introduction

Affine finite automata (AfA) were introduced as a quantum-like “almost” linear111It evolves linearly but a non-linear operator is applied when we retrieve information from the state vector. classical system that has been examined in a series of papers, in which they were compared with classical and quantum finite automata [10, 25, 9, 14]. Both bounded- and unbounded-error AfAs have been shown to be more powerful than their probabilistic and quantum counterparts and they are equivalent to quantum models in nondeterministic acceptance mode [10]. AfAs can also be very succinct on languages and promise problems [25, 9]. Here we present the power of zero-error affine computation on total functions and languages.

Ordered Binary Decision Diagrams (OBDD), also known as oblivious read once branching programs [26], are an important restriction of branching programs. Since the length of an OBDD is fixed (linear), the main complexity measure is “width”, analogous to the number of states used by automata models. OBDDs can also be seen as a variant of nonuniform automata that allow accessing the input in a predetermined order and using possibly different sets of instructions in each step (see [3]). It is known that [4, 5, 1, 6, 2, 12, 22, 18] the gap between the width of the following OBDD models can be at most exponential on total functions: deterministic and bounded-error probabilistic, deterministic and bounded-error unitary, and bounded-error probabilistic and bounded-error unitary. Each exponential gap has also been shown to be tight by giving a function which achieves it. On partial functions, on the other hand, the width gap between deterministic and exact unitary OBDDs can be unbounded [5, 12, 1].

In this paper, we introduce affine OBDDS and then compare error-free (zero-error or Las Vegas) affine, unitary, probabilistic, and deterministic OBDD models. Zero-error probabilistic OBDDs are identical to deterministic OBDDs. Zero-error unitary OBDDs cannot be narrower than deterministic OBDDs. Surprisingly, zero-error affine OBDDs can be exponentially narrower than not only deterministic OBDDs but also bounded-error probabilistic and unitary OBDDs.

With success probability $\frac{1}{2}$, Las Vegas probabilistic and unitary OBDDs can be quadratically narrower than deterministic OBDDs. We give an example function that achieves this bound up to a logarithmic factor.

Finally, we examine the automata counterpart of these models and obtain almost the same results.

Preliminaries and the definitions of the used models are given in the next section. The generic lower bounds are given in Section 3. The results regarding zero-error affine OBDD are given in Section 4 and the results regarding Las Vegas OBDDs are given in Section 5. We close the paper with automata results in Section 6.

2 Preliminaries

We assume the reader familiar with the basics of branching programs, refer to Appendix 0.A for the details.

An oblivious leveled read-once branching program is also called an Ordered Binary Decision Diagram (OBDD). An OBDD $P$ reads the variables in a specific order $\pi=(j_{1},\dots,j_{n})$. We call $\pi$ the order of $P$. An OBDD can also be seen as a non-uniform counterpart of a finite automaton that can read the input symbols in a predetermined order. Therefore an OBDD can trace its computation on a finite set of states $S=\{s_{1},\ldots,s_{m}\}$ such that (i) $m$ is the width of OBDD, (ii) the initial state is the node $s$, (iii) the accepting states are the accepting sink nodes. Thus, each node in any level can be easily associated with a state in $S$. Besides, an OBDD can have a different transition function at each level.

A probabilistic OBDD (POBDD) $P_{n}$ of width $m$ is a 5-tuple:

$P_{n}=(S,T,v_{0},S_{a},\pi),$ where $S=\{s_{1},\ldots,s_{m}\}$ is the set of states corresponding to at most one node in each level, $v_{0}$ is the initial probabilistic state that is a stochastic column vector of size $m$, $S_{a}$ is the set of accepting states corresponding to the accepting sink nodes in the last level, $\pi$ is a permutation of $\{1,\ldots,n\}$ defining the order of the input variables, and, $T=\{T^{0}_{i},T^{1}_{i}\mid 1\leq i\leq n\}$ is the set of (left) stochastic transition matrices such that at the $i$-th step $T_{i}^{0}$ ($T_{i}^{1}$) is applied if the corresponding input bit is 0 (1).

Let $x\in\{0,1\}^{n}$ be the given input. At the beginning of the computation $P_{n}$ is in $v_{0}$. Then the input bits are read in the order $\pi(1),\pi(2),\ldots,\pi(n)$ and the corresponding stochastic operators are applied: $v_{j}=T_{j}^{x_{\pi(j)}}v_{j-1}.$ This represents the transition at the $j$-th step, where $v_{j-1}$ and $v_{j}$ are the probabilistic states before and after the transition respectively, $\pi(j)$ represents the input bit read in this step, $x_{\pi(j)}$ is the value of this bit, and $T_{j}^{x_{\pi(j)}}$ is the stochastic operator applied in this step. We represent the final state as $v_{f}=v_{n}$. The input $x$ is accepted (the value of 1 is given) with probability

[TABLE]

If all stochastic elements of a POBDD are composed of only 0s and 1s, then it is a deterministic OBDD.

Quantum OBDDs (QOBDD) using superoperators are non-trivial generalizations of POBDDs [1]. In this paper, we use the most restricted version of quantum OBDDs called unitary OBDDs (UOBDDs) [13]. Remark that UOBDDs and POBDDs are incomparable [22]. (We refer the reader to [24] for a pedagogical introduction to the basics of quantum computation.)

Formally, a UOBDD, say $M_{n}$, with width $m$ is a 5-tuple

$M_{n}=(Q,T,|v_{0}\rangle,Q_{a},\pi),$ where $Q=\{q_{1},\ldots,q_{m}\}$ is the set of states, $|v_{0}\rangle$ is the initial quantum state, $Q_{a}$ is the set of accepting states, $\pi$ is a permutation of $\{1,\ldots,n\}$ defining the order of the variables, and $T=\{T_{i}^{0},T_{i}^{1}\mid 1\leq i\leq n\}$ is the set of unitary transition function matrices such that at the $i$-th step $T_{i}^{0}$ ($T_{i}^{1}$) is applied if the corresponding input bit is 0 (1).

Let $x\in\{0,1\}^{n}$ be the given input. At the beginning of the computation $M_{n}$ is in $|v_{0}\rangle$. Then the input bits are read in the order $\pi(1),\pi(2),\ldots,\pi(n)$ and the corresponding unitary operators are applied: $|v_{j}\rangle=T_{j}^{x_{\pi(j)}}|v_{j-1}\rangle.$ This represents the transition at the $j$-th step, where $|v_{j-1}\rangle$ and $|v_{j}\rangle$ are the quantum states before and after the transition respectively, $\pi(j)$ represents the input bit read in this step, $x_{\pi(j)}$ is the value of this bit, and $T_{j}^{x_{\pi(j)}}$ is the unitary operator applied in this step. We represent the final state as $|v_{f}\rangle=|v_{n}\rangle$. At the end of the computation, the final state is measured in the computational basis and the input is accepted if the observed state is an accepting one. Thus, the input $x$ is accepted with probability $f_{M_{n}}(x)=\sum_{q_{i}\in Q_{a}}|\langle q_{i}|v_{f}\rangle|^{2},$ where $|q_{i}\rangle$ represents the basis state corresponding to state $q_{i}$ and $\langle q_{i}|v_{f}\rangle$ returns the value of $q_{i}$ in the final state.

An $m$-state affine system [10] can be represented by the space $\mathbb{R}^{m}$. The set of (classical) states is denoted $E=\{e_{1},\ldots,e_{m}\}$. Any affine state (similar to a probabilistic state) is represented as a column vector

[TABLE]

such that $\sum_{i=1}^{m}\alpha_{i}=1$. Each $e_{i}$ also corresponds to a standard basis vector of $\mathbb{R}^{m}$ having value $1$ in its $i$-th entry. An affine operator is an $m\times m$ matrix, each column of which is an affine state, where the $(j,i)$-th entry represents the transition from state $e_{i}$ to state $e_{j}$. If we apply an affine operator $A$ to the affine state $v$, we obtain the new affine state $v^{\prime}=Av$. To get information from the affine state, a non-linear operator called weighting is applied, which returns each state $e_{i}$ with probability equal to the weight of the corresponding vector element in the $l_{1}$ norm of the affine state. If it is applied to $v$, the state $e_{i}$ is observed with probability $\frac{|\alpha_{i}|}{\sum_{j=1}^{n}|\alpha_{j}|}=\frac{|\alpha_{i}|}{|v|},$ where $|v|$ is the $l_{1}$ norm of $v$.

Here we define affine OBDDs (AfOBDDs) as a model with both classical and affine states, which is similar to the quantum model having quantum and classical states [7]. This addition does not change the computational power of the model, but helps in algorithm construction.

Formally, an AfOBDD, say $M_{n}$, having $m_{1}$ classical and $m_{2}$ affine states is an 9-tuple

$M=(S,E,\delta,T,s_{I},v_{0},S_{a},E_{a},\pi),$ where $S=\{s_{1},\ldots,s_{m_{1}}\}$ is the set of classical states, $s_{I}\in S$ is the initial classical state, $S_{a}\subseteq S$ is the set of classical accepting states, $E=\{e_{1},\ldots,e_{m_{2}}\}$ is the set of affine states, $v_{0}\in\mathbb{R}^{m_{2}}$ is the initial affine state, $E_{a}\subseteq E$ is the set of affine accepting states, $\pi$ is a permutation of $\{1,\ldots,n\}$ defining the order of the variables, $\delta=\{\delta_{i}\mid 1\leq i\leq n\}$ is the classical transition function such that at the $i$-th step the classical state is set to $\delta(s,x_{\pi(i)})$ when in state $s\in S$ and corresponding input bit is $x_{\pi(i)}$, and, $T=\{T^{s_{j},0}_{i},T^{s_{j},1}_{i}\mid s_{j}\in S\mbox{ and }1\leq i\leq n\}$ is the set of affine transition matrices such that at the $i$-th step $T_{i}^{s_{j},0}$ ($T_{i}^{s_{j},1}$) is applied if the corresponding input bit is 0 (1) and the current classical state is $s_{j}$. The width of $M_{n}$ is equal to $m_{1}\cdot m_{2}$.

Let $x\in\{0,1\}^{n}$ be the given input. At the beginning of the computation $M_{n}$ is $(s_{I},v_{0})$. Then the input bits are read in the order $\pi(1),\pi(2),\ldots,\pi(n)$. In each step, depending on the current input bit and classical state, the affine state is updated and then the classical state is updated based on the current input bit. Let $(s,v_{j-1})$ be the classical-affine state pair at the beginning of the $j$-th step. Then the new affine state is updated as $v_{j}=T_{j}^{s,x_{\pi(j)}}v_{j-1}.$ After that the new classical state is updated by $\delta_{j}(s,x_{\pi(j)})$. At the end of the computation we have $(s_{F},v_{f})$. If $s_{F}\notin S_{a}$, then the input is rejected. Otherwise, the weighting operator is applied to $v_{f}$, and the input is accepted with probability

[TABLE]

Remark that if an AfOBDD restricted to use non-negative numbers, then we obtain a POBDD.

Any OBDD with $\pi=(1,\ldots,n)$ is called an id-OBDD. If we use the same transitions at each level of an id-OBDD, then we obtain a finite automaton (FA). A FA can also read an additional symbol after reading the whole input called the right end-marker ($$$) for the post-processing. We abbreviate the FA versions of OBDD, POBDD, QOBDD, UOBDD, and AfOBDD as DFA, PFA, QFA, UFA, and AfA, respectively. Remark that UFAs are also known as Measure-Once or Moore-Crutchfield quantum finite automata [20, 8].

A Las Vegas automaton is one that can make three decisions – “accept”, “reject” and “don’t know”. Therefore, its set of states is split into three disjoint sets, the set of accepting, rejecting and neutral states in which the aforementioned decisions are given, respectively. To be a well-defined Las Vegas algorithm, each language member (non-member) must be rejected (accepted) with zero probability.

We assume the reader is familiar with the basic terminology of computing functions and recognizing languages. Here we revise the ones we use in the paper.

A function $f:\{0,1\}^{n}\rightarrow\{1,0\}$ is computed by a bounded-error machine if each member of $f^{-1}(1)$ is accepted with probability at least $1-\epsilon$ and each member of $f^{-1}(0)$ is accepted with probability less than $\epsilon$ for some non-negative $\epsilon<\frac{1}{2}$. If $\epsilon=0$, then it is called exact (zero-error) computation.

In the case of FAs, languages are considered instead of functions and the term “language recognition” is used instead of “computing a function”.

A Las Vegas FA can recognize a language $L$ with success probability $p<1$ (with error bound $1-p$) if each member (non-member) is accepted with probability at least $p$ (less than $1-p$).

For a given language $L$, $\mathsf{DFA(L)}$, $\mathsf{LV_{\varepsilon}(L)}$, and $\mathsf{QLV_{\varepsilon}(L)}$ denote the minimum sizes of a DFA, an LV-PFA and an LV-QFA recognizing the language $L$, respectively, where the error bound is $\varepsilon$ for the probabilistic and quantum models. For a given Boolean function $f$, $\mathsf{OBDD(f)}$, $\mathsf{LV\!-\!OBDD_{\varepsilon}(f)}$, and $\mathsf{ULV\!-\!OBDD_{\varepsilon}(L)}$ denote the minimum sizes of an OBDD, an LV-POBDD and an LV-UOBDDs computing $f$, respectively, where the error bound is $\varepsilon$ for the probabilistic and quantum models. Remark that in the case of zero-error we set $\varepsilon=0$.

3 Lower Bounds

We start with the necessary definitions and notations. Let $X=\{X_{1},\dots,X_{n}\}$ be the set of variables. Let $\theta=(X_{A},X_{B})$ be a partition of the set $X$ into two parts $X_{A}$ and $X_{B}=X\backslash X_{A}$. Let $f|_{\rho}$ be a subfunction of $f$, where $\rho$ is a mapping $\rho:X_{A}\to\{0,1\}^{|X_{A}|}$. The function $f|_{\rho}(X_{B})$ is obtained from $f$ by applying $\rho$. The mapping $\rho$ assigns a Boolean value for each variable from $X_{A}$. Let $N^{\theta}(f)$ be the number of different subfunctions with respect to the partition $\theta$. Let $\Pi(n)$ be the set of all permutations of $\{1,\dots,n\}$. Let $\theta(\pi,u)=(X_{A},X_{B})=(\{X_{j_{1}},\dots,X_{j_{u}}\},\{X_{j_{u+1}},\dots,X_{j_{n}}\})$, for the permutation $\pi=(j_{1},\dots,j_{n})\in\Pi(n),1<u<n$. We denote $\Theta(\pi)=\{\theta(\pi,u):1<u<n\}$. Let $N^{\pi}(f)=\max_{\theta\in\Theta(\pi)}N^{\theta}(f),$ $N(f)=\min_{\pi\in\Pi(n)}N^{\pi}(f).$

Based on techniques from communication complexity theory, it has been shown that exact quantum and probabilistic protocols have at least the same complexity as deterministic ones [19, 15]. The following lower bounds are also known.

Fact 1

[11, 19, 16, 15]** For any regular language $L$ and error bound $\varepsilon<1$, we have the following lower bounds for PFAs and QFAs:

$(\mathsf{DFA(L)})^{1-\varepsilon}\leq\mathsf{LV_{\varepsilon}(L)}\mbox{ and }(\mathsf{DFA(L)})^{1-\varepsilon}\leq\mathsf{ULV_{\varepsilon}(L)}.$**

Fact 2

[22]** For any Boolean function $f$ over $X=(X_{1},\dots,X_{n})$ and error bound $\varepsilon<1$: $(\mathsf{OBDD(f)})^{1-\varepsilon}\leq\mathsf{ULV\!-\!OBDD_{\varepsilon}(f)}.$

We can easily extend this result for the probabilistic OBDD model as well.

Theorem 3.1

For any Boolean function $f$ over $X=\{X_{1},\dots,X_{n}\}$ and error bound $\varepsilon<1$: $(\mathsf{OBDD(f)})^{1-\varepsilon}\leq\mathsf{LV\!-\!OBDD_{\varepsilon}(f)}.$

Proof

Let $d=\mathsf{OBDD(f)}$. Due to [26], we have $N(f)=d$. Assume that there is a Las Vegas OBDD $P$ of width $w$ such that $w<d^{1-\varepsilon}$. Let $u=\texttt{argmax}_{t}N^{\theta(\pi(P),t)}(f)$ and $\theta=\theta(\pi(P),u)$. Then $P$ can be simulated by a Las Vegas probabilistic protocol (see [17]) with $\log_{2}{w}<(1-\varepsilon)\log_{2}d$ bits. By the definition of the number of subfunctions, we have $N^{\theta}(f)\geq d$. And it is known that the deterministic communication complexity of a function is $\log_{2}(N^{\theta}(f))=\log_{2}d$. But we also have a Las Vegas communication protocol which uses $\log_{2}{w}<(1-\varepsilon)\log_{2}d$ communication bits, giving a contradiction with [15]. In that paper it was shown that, if the best deterministic communication protocol sends $r$ bits, then a Las Vegas protocol with an $\varepsilon$ probability of giving up cannot send less than $(1-\varepsilon)r$ bits. ∎

It is trivial that these results imply equivalence for exact (zero-error) computation, where $\varepsilon=0$.

4 Zero-Error Affine OBDDs

We show that exact AfOBDDs can be exponentially narrower than classical and unitary quantum OBDD models. For this purpose we use three different functions.

The hidden weighted bit function [26] $\mathtt{HWB_{n}}:\{0,1\}^{n}\to\{0,1\}$ returns the value of $x_{z}$ on the input $x=(x_{1},\dots,x_{n})$ where $z=x_{1}+\cdots+x_{n}$, taking $x_{0}=0$. It is known [26] that any OBDD solving $\mathtt{HWB_{n}}$ has a minimum width of $2^{n/5}/n$. Remark that due to Fact 2 and Theorem 3.1, the same bound is also valid for exact POBDDs and UOBDDs.

Theorem 4.1

An exact id-AfOBDD $M$ with $n$ classical and $n$ affine states can solve $\mathtt{HWB_{n}}$.

Proof

The classical states are $s_{0},\ldots,s_{n-1}$ where $s_{0}$ is the initial and only accepting state. The affine states are $e_{0},\ldots,e_{n}$ where $e_{0}$ is the only accepting affine state and $v_{0}$ is $e_{0}$.

Until reading the last input bit ($x_{n}$), for each value 1, the index of the classical state is increased by 1. Meanwhile, the value of $x_{i}$ is written to the value of $e_{i}$ in the affine state: the affine state after the $(i-1)$-th step becomes $v_{i-1}=(\overline{1}~{}~{}x_{1}~{}~{}\cdots~{}~{}x_{i-1}~{}~{}0~{}~{}\cdots~{}~{}0)^{T}$, where $\overline{1}=1-\sum_{j=1}^{i-1}x_{j}$. If $x_{i}=0$, then the identity operator is applied. If $x_{i}=1$, then the following affine transformation is applied

[TABLE]

which updates the values of $e_{0}$ and $e_{i}$ as $-\sum_{j=1}^{i-1}x_{j}$ and 1, respectively, and does not change the other entries. Remark that the first entry can also be written as $1-\sum_{j=1}^{i}x_{j}$.

Thus, before reading $x_{n}$, the classical state is $s_{t}$ for $t=\sum x_{1}+\cdots+x_{n-1}$, and, the affine state is $v_{n-1}=(\overline{1}~{}~{}x_{1}~{}~{}x_{2}~{}~{}\cdots~{}~{}x_{n-1})^{T},$ where $\overline{1}$ is $1-\sum_{j=1}^{n-1}x_{j}$.

After reading $x_{n}$, the classical state is always set to $s_{0}$ and so the decision is made based on the affine state. The pair $s_{t}$ and $x_{n}$ determines the last affine transformation that sets the final affine state to $v_{f}=(x_{z}~{}~{}1-x_{z}~{}~{}0~{}~{}\cdots~{}~{}0)^{T}.$ Here (i) if $t=0$ and $x_{n}=0$, $x_{z}=0$, (ii) if $t=n-1$, then regardless the value of $x_{n}$, $x_{z}=1$, and (iii) in any other case $z=t+x_{n}$ and $x_{z}$ is set to the $(z+1)$-th entry of $v_{n-1}$. Thus, if $x_{z}=0$ ($x_{z}=1$), then the input is accepted with probability 0 (1). ∎

For a positive integer $n$, let $x,y$ be inputs of size $n$, let $p(n)$ be the smallest prime number greater than $n$, and let $s_{n}(x)=\left(\sum_{i=1}^{n}i\cdot x_{i}\right)\ \mathrm{mod}\ p(n)$.

We use two functions [21]. The weighted sum function $\mathtt{WS_{n}}(x):\{0,1\}^{n}\rightarrow\{0,1\}$ is defined as $\mathtt{WS_{n}}(x)=x_{s_{n}(x)}$ if $s_{n}(x)\in\{1,\dots,n\}$, and [math] otherwise. The mixed weighted sum function $\mathtt{MWS_{n}}:\{0,1\}^{n}\times\{0,1\}^{n}\rightarrow\{0,1\}$ is defined as $\mathtt{MWS_{n}}(x,y)=x_{i}\oplus y_{i}$ if $i=s_{n}(x)=s_{n}(y)\in\{1,\dots,n\}$, and [math] otherwise.

Any bounded-error POBDD or UOBDD solving $\mathtt{MWS_{n}}$ has a width of at least $2^{\Omega(n)}/n$ [23, 21]. The same bound is also valid for OBDDs, and so for exact POBDDs and UOBDDs as well.

Theorem 4.2

An exact id-AfOBDD can solve $\mathtt{WS_{n}}$ with $p(n)$ classical states and $n$ affine states.

Proof

We use almost the same algorithm given in the previous proof. The affine part is the same. The new classical states are $s_{0},\ldots,s_{p(n)-1}$ with the same initial and single accepting state $s_{0}$.

Until reading $x_{n}$, the same affine transitions are applied:

$v_{n-1}=(\overline{1}~{}~{}x_{1}~{}~{}x_{2}~{}~{}\cdots~{}~{}x_{n-1})^{T},$ where $\overline{1}$ is $1-\sum_{j=1}^{n-1}x_{j}$. The classical transitions are modified as follows: The classical state before reading $x_{i}$ ($i<n$), say $s_{j}$, is set to $s_{j+i\cdot x_{i}\ \mathrm{mod}\ p(n)}$. Thus, before reading $x_{n}$, the classical state is $s_{t}$ where $t=\left(\sum_{i=1}^{n-1}i\cdot x_{i}\right)\ \mathrm{mod}\ p(n)$.

At this point, the pair $s_{t}$ and $x_{n}$ sets the affine state to

$v_{f}=(x_{s_{n}(x)}~{}~{}1-x_{s_{n}(x)}~{}~{}0~{}~{}\cdots~{}~{}0)^{T}$ and then the classical state is set to $s_{0}$. Here $x_{s_{n}(x)}=0$ if $t+n\cdot x_{n}\ \mathrm{mod}\ p(n)\notin\{1,\ldots,n\}$. Otherwise, depending on the value of $s_{n}(x)$, $x_{s_{n}(x)}$ is set to the corresponding value from $v_{n-1}$ or directly to $x_{n}$. ∎

Theorem 4.3

An exact id-AfOBDD can solve $\mathtt{MWS_{n}}$ with $p^{2}(n)$ classical states and $(n+1)$ affine states.

Proof

The classical states are $\{s_{i,j}\mid 0\leq i,j<p(n)\}$ where $s_{0,0}$ is the initial state and the accepting states are $\{s_{i,i}\mid 1\leq i\leq n\}$. By reading all bits, the values of $s_{n}(x)$ and $s_{n}(y)$ are calculated and stored in the indexes of classical states in a straightforward way. Let $s_{i,j}$ be the final state. It is clear that if $i\neq j$ or $i=j$ but not in $\{1,\ldots,n\}$, the input is rejected classically. In the remaining part, we assume that the final classical state is $s_{i,i}$ with $i\in\{1,\ldots,n\}$. Thus, the final decision is given based on the final affine state.

The affine states are $\{e_{0},\ldots,e_{n}\}$ where $e_{0}$ is the single accepting state. The initial affine state is $v_{0}=e_{0}$.

While reading the first part of the input, all $x$ values are encoded in the affine state as $(\overline{1}~{}~{}(-1)^{x_{1}}~{}~{}(-1)^{x_{2}}~{}~{}\cdots~{}~{}(-1)^{x_{n}})^{T},$ where $\overline{1}=1-\sum_{i=1}^{n}(-1)^{x_{i}}$. Then, for each $y_{j}$ ($1\leq j\leq n$), we multiply the $j$-th entry of the affine state by $(-1)^{y_{j}}$. Thus, the $j$-th entry becomes $(-1)^{x_{j}+y_{j}}$, which is equal to $1$ if $x_{j}=y_{j}$ and $-1$ if $x_{j}\neq y_{j}$.

The last affine transformation is composition of three affine transformations. The first transformation is the one explained above. By using the second one, the affine state is set to $((-1)^{x_{i}+y_{i}}~{}~{}~{}~{}1-(-1)^{x_{i}+y_{i}}~{}~{}~{}~{}0~{}~{}\cdots~{}~{}0)^{T}.$

Here the first two entries are $(1~{}~{}0)$ for members and $(-1~{}~{}2)$ for non-members. By using the third transformation, we can add the half the of second entry to the first entry and so get respectively $(1~{}~{}0)$ and $(0~{}~{}1)$. Thus, the AfOBDD can separate members from non-members with zero error. ∎

5 Las Vegas POBDDs and UOBDDs

For OBDDs with $\varepsilon=\frac{1}{2}$ the lower bound given in Section 3 can be at most quadratic. Up to a logarithmic factor, this quadratic gap was achieved by using the $\mathtt{SA_{d}}$ function in [22] for id-OBDDs. Here we give the same result for OBDDs (for any order) using the $\mathtt{SSA_{n}}$ function and also provide an LV-UOBDD algorithm with the same size as the LV-OBDD.

We start with the well-known Storage Access Boolean Function $\mathtt{SA_{d}}(x,y)=x_{y}$, where the input is split into the storage $x=(x_{1},\dots,x_{2^{d}})$ and the address $y=(y_{1},\dots,y_{d})$.

By using the idea of “Shuffling” from [2, 6, 5, 1] we define the Shuffled Storage Access Boolean function $\mathtt{SSA_{n}}:\{0,1\}^{n}\to\{0,1\}$, for even $n$. Let $x\in\{0,1\}^{n}$ be an input. We form two disjoint sorted lists of even indexes of bits $I_{0}=(2i_{1},\dots,2i_{m})$ and $I_{1}=(2j_{1},\dots,2j_{k})$ with the following properties: (i) if $x_{2i-1}=0$ then $2i\in I_{0}(x$, (ii) if $x_{2i-1}=1$ then $2i\in I_{1}(x)$, (iii) $i_{r}<i_{r+1}$, for $r\in\{1,\dots,m-1\}$ and $j_{r}<j_{r+1}$ , for $r\in\{1,\dots,k-1\}$.

Let $d$ be such that $2^{d}+d=n/2$. We can construct two binary strings by the following procedure: initially $\alpha(x):=0^{2^{d}}$, then for $r$ from $1$ to $m$ we do $\alpha(x):=\mathtt{ShiftX}(\alpha(x),x_{2i_{r}})$, where $\mathtt{ShiftX}((a_{1},...,a_{m}),b)=(a_{2},...,a_{m},a_{1}\oplus b)$. And initially $\beta(x):=0^{d}$, then for $r$ from $1$ to $k$: $\beta(x):=\mathtt{ShiftX}(\beta(x),x_{2j_{r}})$. Then, $\mathtt{SSA_{n}}(x)=\mathtt{SA_{d}}(\alpha(x),\beta(x))$.

Firstly, we provide a lower bound for OBDDs. (See Appendix 0.B for the proof.)

Theorem 5.1

$\mathsf{OBDD(\mathtt{SSA_{n}})}\geq 2^{2^{d}}$, for $2^{d}+d=n/2$.

Now, we provide an upper bound for LV-OBDDs.

Theorem 5.2

$\mathsf{LV\!-\!OBDD_{0.5}(\mathtt{SSA_{n}})}\leq 2^{2^{d}/2+d+3}$, for $2^{d}+d=n/2$.

Proof

The proof idea is to store and process even and odd bits of storage separately in two different paths and then the path containing the index makes the correct decision and the other path ends with the answer of “don’t know”. The formal proof is as follows.

Firstly, we describe the states. Associate each state of each odd level with a quartet $(s,t,e,a)$, where $s\in\{0,\dots,2^{2^{d}/2}-1\}$ is the string of stored bits, $t\in\{0,1\}$ is a Boolean variable marking whether we should store the next bit or not, $e\in\{0,1\}$ is a Boolean variable marking whether we store odd bits or bit or not and $a\in\{0,\dots,2^{d}-1\}$ is the address. We associate each state of each even level with a quintet $(s,t,e,a,b)$, where $s\in\{0,\dots,2^{2^{d}/2}-1\}$, $t,e\in\{0,1\}$ and $a\in\{0,\dots,2^{d}-1\}$ have the same meaning, and $b\in\{0,1\}$ is the odd input bit in the current pair to know whether we should process the next bit as a storage bit or an address bit. We have the same set of states in both odd and even levels, but we do not use some states in odd levels.

On the first level the program reads the bit $x_{1}$ and starts in one of the $(0,0,0,0,x_{1})$ and $(0,1,1,0,x_{1})$ with equal probability $\frac{1}{2}$, and so chooses whether the algorithm will store odd or even bits of storage. Let us describe the transitions of other levels. First, let us consider an odd level for a variable $x_{i}$. The program goes from the state $(s,t,a)$ to the state $(s,t,e,a,x_{i})$. Second, let us consider an even level for a variable $x_{i}$. Being in a state $(s,t,e,a,0)$ means that the current bit is a storage bit. If $t=0$, then the program should skip the bit and go to the state $(s,1-t,e,a)$ on the next level. If $t=1$, then the program should store the bit by going to the state $(\mathtt{ShiftX}_{2^{d}/2}(s,x_{i}),1-t,e,a)$ on the next level, where $\mathtt{ShiftX}_{u}(v,b)$ converts the integer $v$ to a binary string $v$ of length $u$ and applies the $\mathtt{ShiftX}(u,b)$ operation, then converts the result back to an integer. Being in a state $(s,t,e,a,1)$ means that the current bit is an address bit. The program then goes to the state $(s,t,e,\mathtt{ShiftX}_{d}(a,x_{i}))$. On the last level, if $e=a\ \mathrm{mod}\ 2$ then the address contains the index of a stored bit and the program returns its value, otherwise the program returns “don’t know”.

The width of the program: $\mathtt{width}(P)=2^{2^{d}/2}\cdot 2\cdot 2\cdot 2^{d}\cdot 2=2^{2^{d}/2+d+3}$. ∎

Theorem 5.3

$\mathsf{ULV\!-\!OBDD_{0.5}(\mathtt{SSA_{n}})}\leq 2^{2^{d}/2+d+3}$, for $2^{d}+d=n/2$.

Proof

(Sketch. Full proof is in Appendix 0.C) We can construct a Las Vegas UOBDD from the probabilistic version, using Hadamard transformation instead of choosing states with equal probability. We use he same trick in next section in Theorem 6.3. Note that $\mathtt{ShiftX}_{u}(v,b)$ is a reversible operation and can be implemented as a unitary operator. ∎

We note that affine OBDDs can also be exponentially narrower for $\mathtt{SSA_{n}}$.

Theorem 5.4

An exact AfOBDD $A$ can solve $\mathtt{SSA_{n}}$ with $2^{d+1}$ classical states and $2^{d}+1$ affine states, for $2^{d}+d=n/2$.

Proof

The set of classical states is $\{(p,s)\mid p\in\{p_{0},p_{1}\}\mbox{ and }s\in\{s_{0},\ldots,s_{2^{d}-1}\}\}$, for a total of $2^{d+1}$ states. The states $p_{j}$ denote whether the next even bit to read is a storage or address bit. The state $s_{i}$ corresponds to the current address being $i$. Every classical state is accepting, and so the decision is given based on the final affine state.

The AfOBDD also has $2^{d}+1$ affine states, $\{e_{1},\ldots,e_{2^{d}+1}\}$. The initial state is $e_{2^{d}+1}$ ($v_{0}=\left(0~{}~{}\cdots~{}~{}0~{}~{}1\right)^{T}$) and the only accepting state is $e_{1}$.

During the computation, it keeps the value of the storage in the first $2^{d}$ states. Specifically, if the next position to read is odd, or even but an address bit (we are in a state $(p_{1},s_{i}$)) we perform the identity transformation on the affine state, changing only the classical state. If we are reading a storage bit, the classical state remains unchanged and we implement the $\mathtt{ShiftX}$ operation on the storage: first, the $2^{d}$ entries are shifted to the left by one and the first entry becomes the $2^{d}$-th entry. Then, depending on the scanned symbol, the value of the $2^{d}$-th entry is updated:

• •

If the scanned symbol is [math], then, for calculating the $XOR$ value, the $2^{d}$-th entry is multiplied by 1, i.e., $0\rightarrow 0$ and $1\rightarrow 1$.

• •

If the scanned symbol is $1$, then, for calculating the $XOR$ value, the $2^{d}$-th entry is multiplied by $-1$ and then 1 is added to this result, i.e., $0\rightarrow 0\rightarrow 1$ and $1\rightarrow-1\rightarrow 0$.

The last entry in the affine state is used to make the state vector well-formed. For example, if the state vector has $0\leq t\leq 2^{d}$ 1s in its first $2^{d}$ entries, then the last entry is $1-t$.

After reading the whole input, the first $2^{d}$ entries keep the storage. We know the address $i$ from our classical state $s_{i}$ – we move the corresponding storage value from $e_{i}$ to $e_{1}$ and sum all other entries in $e_{2}$. Then, if the first entry is 1, the rest of the vector contains only 0. If the first entry is 0, the second entry is 1 and the rest of the vector contains 0.

Therefore, any member of $\mathtt{SSA_{n}}$ is accepted by $A$ with probability 1 and any non-member is accepted by $A$ with probability 0.∎

6 Las Vegas Automata and Zero-Error AfAs

Similar to OBDDs, for $\varepsilon=\frac{1}{2}$, the lower bound for finite automata given in Section 3 can be at most quadratic. Up to a constant, this quadratic gap is achieved by using the language $\mathtt{END_{k}}=\{u1v\mid u,v\in\{0,1\}^{*}\mbox{ and }|v|=k-1\}$:

$\mathsf{DFA(\mathtt{END_{k}})}=2^{k}\mbox{ and }\mathsf{LV_{0.5}(\mathtt{END_{k}})}\leq 4\cdot 2^{k/2}.$

Here, we propose a new language $\mathtt{MODXOR_{k}}$ based on which we improve the above constant for LV-PFAs and provide a LV-UFA algorithm with the same size as the LV-PFA. Then, we show that an AfA can recognize it with exponentially fewer states with zero error. The language $\mathtt{MODXOR_{k}}$ for $k>0$ is formed by the strings $\{0,1\}^{<2k}x_{1}\{0,1\}^{2k-1}x_{2}\{0,1\}^{2k-1}\cdots x_{m}\{0,1\}^{2k-1}$ where $m>0$, each $x_{i}\in\{0,1\}$ for $1\leq i\leq m$, and $\bigoplus_{i=0}^{m}x_{i}=1$, taking $x_{0}=0$.

First, we give a lower bound for DFAs. (See Appendix 0.D for the proof.)

Theorem 6.1

$\mathsf{DFA(\mathtt{MODXOR_{k}})}\geq 2^{2k}$* for each $k>0$.*

Theorem 6.2

$\mathsf{LV_{0.5}(\mathtt{MODXOR_{k}})}\leq 2\cdot 2^{k}$* for any $k>0$.*

Proof

We construct an LV-PFA, say $P$, with success probability $\frac{1}{2}$. At the beginning of the computation, it splits into two paths with equal probability and in each path only deterministic transitions are implemented. In the first (second) path, it assumes that $x_{i}$’s are placed on odd (even) indexes. The set of states is formed by $\{(p,s)\mid p\in\{p_{0},p_{1}\}\mbox{ and }s\in\{s_{(0)},\ldots,s_{(2^{k}-1)}\}\}$ where the index of $s_{(i)}$, $(i)$, is a binary string of length $k$ that represents the value of $i$. The number of states is $2\cdot 2^{k}$.

The first path starts in $(p_{1},s_{(0)})$ and the second path starts in $(p_{0},s_{(0)})$. Both paths use the same transitions. If $P$ is in a state $(p_{0},s)$, then it always switches to $(p_{1},s)$, i.e. the second part of the state does not change. If it is in $(p_{1},s_{(i)})$ and reads a symbol $x\in\{0,1\}$, then it switches to $(p_{0},s_{(j)})$, where $(j)$ is obtained from $(i)$ as follows:

• •

$(j)_{k}=x\oplus(i)_{1}$ and

• •

$(j)_{l}=(i)_{l+1}$ for $1\leq l<k$.

Remark that all transitions in each path are reversible. It is clear that the first (second) path considers only the symbols at odd (even) indexes.

If the automaton ends in a state $(p_{0},s)$, then it says “don’t know”, since the initial guess was not correct and so the other path has the correct answer. If it ends in $(p_{1},s_{(i)})$, then the decision is given based on the first digit of $(i)$: the input is accepted (rejected) if $(i)_{1}=1$ ($(i)_{1}=0$).

Lastly, since the initial state has $s_{(0)}$, $x_{0}$ is correctly assumed to be [math]. Besides, if the length of the input is less than $2k$, then $P$ never accepts since the first bit of $(0)$ can not be changed before $2k$ steps. ∎

Theorem 6.3

$\mathsf{ULV_{0.5}(\mathtt{MODXOR_{k}})}\leq 2\cdot 2^{k}$* for any $k>0$.*

Proof

We can follow the construction given for PFA. As pointed out in the above proof, both paths implement a deterministically reversible transitions and so they can be implemented by a UFA. Instead of an initial probabilistic distribution, the initial quantum state is set to $\frac{1}{\sqrt{2}}|p_{0},s_{0}\rangle+\frac{1}{\sqrt{2}}|p_{1},s_{0}\rangle.$

Then, both paths stay in superposition but each of them implements its part separately from the other. To be more precise, the unitary operator for a symbol can be defined as follows:

[TABLE]

where $S=\{s_{(0)},\ldots,s_{(2^{k}-1)}\}$. Since $R$ is reversible (unitary), the overall matrix is unitary. The accepting states are $\{(p_{1},s_{(1i^{\prime})})\}$ where $i^{\prime}$ is any binary string of length $k-1$. ∎

Similarly to OBDDs, exact AfAs can also be exponentially more efficient than their classical and quantum counterparts.

Theorem 6.4

The language $\mathtt{MODXOR_{k}}$ for $k>0$ can be recognized by a ($2k+1$)-state AfA $A$ with zero-error.

Proof

The AfA $A$ does not use any classical state and it has $2k+1$ affine states, $\{e_{1},\ldots,e_{2k+1}\}$. The initial state is $e_{2k+1}$ and the only accepting state is $e_{1}$. It starts its computation in $v_{0}=\left(0~{}~{}\cdots~{}~{}0~{}~{}1\right)^{T}$.

During the computation, it keeps the results in the values of the first $2k$ states, i.e. it sets the values 0 or 1 depending the previous results and the current scanning symbols. More specifically, before each transition, the first $2k$ entries are shifted to the right by one and the $2k$-th entry becomes the first entry. Then, depending on the scanned symbol, the value of the first entry is updated:

• •

If the scanned symbol is [math], then, for calculating $XOR$ value, the first entry is multiplied by 1, i.e., $0\rightarrow 0$ and $1\rightarrow 1$.

• •

If the scanned symbol is $1$, then, for calculating $XOR$ value, the first entry is multiplied by $-1$ and then 1 is added to this result, i.e., $0\rightarrow 0\rightarrow 1$ and $1\rightarrow-1\rightarrow 0$.

The last entry in the affine state is used to make the state vector well-formed. For example, if the state vector has $0\leq t\leq 2k$ 1s in its first $2k$ entries, then the last entry is $1-t$.

After reading the whole input, the first entry keeps the result. The rest of entries are summed to the second entry. Thus, if the first entry is 1, then the rest of the vector contains only 0. If the first entry is 0, then the second entry is 1 and the rest of the vector contains zeros.

Therefore, any member is accepted by $A$ with probability 1 and any non-member is accepted by $A$ with probability 0. ∎

Acknowledgements. The work is partially supported by ERC Advanced Grant MQC and the Latvian State Research Programme NeXIT project No. 1. The work is performed according to the Russian Government Program of Competitive Growth of Kazan Federal University.

Appendix 0.A Basics of Branching Programs

A branching program $P_{n}$ on the variable set $X=\{X_{1},\ldots,X_{n}\}$ is a finite directed acyclic graph with one source node $s$ and some sink nodes partitioned into two sets, Accept and Reject. Each inner node of $P$ is associated with a variable $X_{i}\in X$ and has two outgoing edges labeled $X_{i}=0$ and $X_{i}=1$. The program $P_{n}$ computes the Boolean function $f(x)$ ($f:\{0,1\}^{n}\rightarrow\{0,1\}$) as follows. For any $x\in\{0,1\}^{n}$ the computation starts from $s$ and follows a path depending on the bits of $x$ – in each vertex the related bit is tested and the next node is selected according to its value. If it ends in a sink node belonging to Accept (Reject), the input $x$ is accepted (rejected). For an accepted (rejected) input, the function takes the value 1 (0).

A branching program is leveled if the nodes can be partitioned into levels $V_{1},\ldots,V_{\ell}$ and a final level $V_{\ell+1}$ such that (i) $s$ belongs to $V_{1}$, (ii) the nodes in $V_{\ell+1}$ are the sink nodes, (iii) nodes in each level $V_{j}$ with $j\leq\ell$ have outgoing edges only to nodes in the next level $V_{j+1}$.

The width of a leveled branching program $\texttt{width}(P_{n})$ is the maximum of number of nodes in a level of $P_{n}$, i.e. $\texttt{width}(P_{n})=\max_{1\leq j\leq\ell}|V_{j}|$. The size of a branching program $P_{n}$ is the total number of nodes.

A leveled branching program is called oblivious if all inner nodes of one level are associated with the same variable. A branching program is called read-once if each variable is tested on each path only once.

Appendix 0.B Proof of Theorem 5.1

Let us consider any input order $\pi=(i_{1},\dots,i_{n})$. Let $\pi^{\prime}=(j_{1},\dots,j_{n/2})$ be only the even indexes according to $\pi$. Let $\Sigma\subset\{0,1\}^{n}$ be the set of inputs such that for any $\sigma\in\Sigma$ we have: $I_{0}(\sigma)=\{j_{1},\dots,j_{2^{d}}\}$ and $I_{1}(\sigma)=\{j_{2^{d}+1},\dots,j_{2^{d}+d}\}$. Informally, it means that the first $2^{d}$ even bits are the storage and the last $d$ even bits are the address.

Let us consider a partition of the input positions $\theta=(X_{A},X_{B})=\theta(\pi,u)$ such that $X_{j_{r}}\in X_{A}$, for $r\in\{1,\dots,2^{d}\}$ and $X_{j_{r}}\in X_{B}$, for $r\in\{2^{d}+1,\dots,2^{d}+d\}$. Informally, it means that the first $2^{d}$ even bits read belong to $X_{A}$ and the last $d$ even bits read belong to $X_{B}$. We now consider the partition of an input $\sigma=(\xi,\gamma)$ according to $\theta$. It is easy to see that $\beta(\sigma)$ depends only on $\gamma$. Let us denote it $\beta^{\prime}(\gamma)=\beta(\sigma)$.

Let $K=\{\xi:(\xi,\gamma)\in\Sigma$ for some $\gamma\in\{0,1\}^{|X_{B}|}\}$. We will show that for any different $\xi,\xi^{\prime}\in K$ and mappings $\rho:X_{A}\to\xi,\rho^{\prime}:X_{A}\to\xi^{\prime}$ the corresponding subfunctions $\mathtt{SSA_{n}}|_{\rho}$ and $\mathtt{SSA_{n}}|_{\rho^{\prime}}$ are different.

Let $\xi,\xi^{\prime}\in K$ and $\xi\neq\xi^{\prime}$, it means there is an even $j_{r}$ such that $\xi_{j_{r}}\neq\xi^{\prime}_{j_{r}}$. Let us choose $\gamma$ such that $\beta^{\prime}(\gamma)=(j_{r}/2)$. Let $\sigma=(\xi,\gamma)$ and $\sigma^{\prime}=(\xi^{\prime},\gamma)$. Then $\mathtt{SSA_{n}}(\sigma)=\xi_{j_{r}}\neq\xi^{\prime}_{j_{r}}=\mathtt{SSA_{n}}(\sigma^{\prime})$, therefore $\mathtt{SSA_{n}}|_{\rho}(\gamma)\neq\mathtt{SSA_{n}}|_{\rho^{\prime}}(\gamma)$, so these are different subfunctions.

Hence $N^{\theta}(\mathtt{SSA_{n}})\geq|K|=2^{2^{d}}$. Then, by definition, $N^{\pi}(\mathtt{SSA_{n}})\geq N^{\theta}(\mathtt{SSA_{n}})\geq 2^{2^{d}}$. This holds for any order $\pi$, therefore $N(\mathtt{SSA_{n}})\geq 2^{2^{d}}$. We know from [26] that $N(\mathtt{SSA_{n}})=\mathsf{OBDD(\mathtt{SSA_{n}})}$, completing the proof.

Appendix 0.C Proof of Theorem 5.3

The proof idea is to store and process even and odd bits of the storage separately in two different paths and then the path containing the index makes the correct decision and the other path ends with the answer “don’t know”. The formal proof is as follows.

Firstly, we describe the states. Associate each state of each odd level with a quartet $(s,t,e,a)$, where $s\in\{0,\dots,2^{2^{d}/2}-1\}$ is the string of stored bits, $t\in\{0,1\}$ is a Boolean variable marking whether we should store the next bit or not, $e\in\{0,1\}$ is a Boolean variable marking whether we store odd bits or bit or not and $a\in\{0,\dots,2^{d}-1\}$ is the address. We associate each state of each even level with a quintet $(s,t,e,a,b)$, where $s\in\{0,\dots,2^{2^{d}/2}-1\}$, $e,t\in\{0,1\}$ and $a\in\{0,\dots,2^{d}-1\}$ have the same meaning, and $b\in\{0,1\}$ is the odd input bit in the current pair to know whether we should process the next bit as a storage bit or an address bit. We have the same set of states in both odd and even levels, but we do not use some states in odd levels.

On the first level the program reads the bit $x_{1}$ and starts in the states $(0,0,0,0,x_{1})$ and $(0,1,1,0,x_{1})$ with equal amplitude $1/\sqrt{2}$, thus choosing whether the algorithm will store odd or even bits of the storage.

Let us describe the transitions of other levels. First, let us consider an odd level for a variable $x_{i}$. The program goes from the state $(s,t,e,a)$ to the state $(s,t,e,a,x_{i})$. Second, let us consider an even level for a variable $x_{i}$. Being in a state $(s,t,e,a,0)$ means that the current bit is a storage bit. If $t=0$, then the program should skip this bit and go to the state $(s,1-t,a)$ on the next level. If $t=1$, then the program should store the bit by going to the state $(\mathtt{ShiftX}_{2^{d}/2}(s,x_{i}),1-t,a)$ on the next level, where $\mathtt{ShiftX}_{u}(v,b)$ converts the integer $v$ to a binary string $v$ of length $u$ and applies the $\mathtt{ShiftX}(u,b)$ operation, then converts the result back to an integer. Being in a state $(s,t,e,a,1)$ means that the current bit is an address bit. The program then goes to the state $(s,t,e,\mathtt{ShiftX}_{d}(a,x_{i}))$.

After the last level the program is in the state $\frac{1}{\sqrt{2}}p_{0}+\frac{1}{\sqrt{2}}p_{1}$, where $p_{0}$ is the state corresponding to $(s,t,0,a)$ and $p_{1}$ is the state corresponding to $(s^{\prime},t,1,a)$, where $s$ are even storage bits and $s^{\prime}$ are odd storage bits. Then the program measures qubits and gets one of the two states $p_{0}$ or $p_{1}$ with probability $1/2$. If the program gets $p_{0}$ and $a$ is even or $p_{1}$ and $a$ is odd, then it can return the right answer. If the program gets $p_{0}$ and $a$ is odd or $p_{1}$ and $a$ is even, then it returns “don’t know”.

The width of the program is $\mathtt{width}(P)=2^{2^{d}/2}\cdot 2\cdot 2\cdot 2^{d}\cdot 2=2^{2^{d}/2+d+3}$.

Appendix 0.D Proof of Theorem 6.1

Let us consider $2^{2k}$ classes of words $C_{1},\dots C_{2^{2k}}$. Let $(a_{0},\dots,a_{2k-1})=(z)$ be the binary representation of $z$. A word $w$ is in $C_{z}$ iff for any $j\in\{0,\dots,2k-1\}$ the following holds:

[TABLE]

Let us show that two words from different classes are not equivalent by Myhill-Nerode.

Let $w\in C_{z},w^{\prime}\in C_{z^{\prime}}$, $z\neq z^{\prime}$. It means that for $(a_{0},\dots,a_{2k-1})=(z)$ and $(a^{\prime}_{0},\dots,a^{\prime}_{2k-1})=(z^{\prime})$ there exists a $j$ such that $a_{j}\neq a^{\prime}_{j}$. Without loss of generality, we can assume that $a_{j}=1$, $a^{\prime}_{j}=0$.

Let us consider a word $v$ such that $|v|=2k-1-j$. Then, by the definition of the function, $wv\in\mathtt{MODXOR_{k}}$ and $w^{\prime}v\not\in\mathtt{MODXOR_{k}}$.

Due to the Myhill-Nerode Theorem, the number of states required by a minimal DFA is the number of classes. Hence, $\mathsf{DFA(\mathtt{MODXOR_{k}})}\geq 2^{2k}$.