1 Introduction
Affine finite automata (AfAs) are quantumlike generalization of probabilistic finite automata (PFAs) mimicking quantum interference and having the capability of “making measurement” based on norm (called weighting). The computation of an AfA is linear, but the weighting operators may be nonlinear.
AfAs was formally defined in [7], and it was shown that they are more powerful than PFAs and quantum finite automata (QFAs) in boundederror and unboundederror settings, but their nondeterministic version is equivalent to nondeterministic QFAs. Since then, AfAs and their different generalizations (e.g., OBDDs and using counters) have been investigated in a series of work [28, 14, 22, 17, 29, 15, 16].
In this paper, we initiate the study of the verification power of AfAs as part of ArthurMerlin (AM) proof systems. We show that every unary language is verified by a realvalued AfA verifier. Then, we focus on the verifiers restricted to have only integervalued or rationalvalued transitions. We observe that rationalvalued verifiers can be simulated by integervalued verifiers, and, their protocols can be simulated in nondeterministic polynomial time. We show that this bound tight by presenting an AfA verifier for NPcomplete problem . We also show that AfAs can verify certain nonaffine and nonstochastic unary languages. In our protocols, we use similar verification strategies and encoding techniques previously used for twoway QFAs in [33, 30, 26].
In the rest of this section, we provide a quick literature review related to our results. We give the notation and definitions in Section 2, and we review some basic computation techniques by integervalued affine states and operators used in our proofs in Section 3. We present our main result on unary languages in Section 4, and our results on rational or integervalued AfAs are given in Section 5. We close the paper by summarizing our results with previously known related results based on complexity classes in Section 6.
1.1 The computational power of AfAs compared to PFAs and QFAs
We review the previously known results comparing AfAs with PFAs and QFAs.
Boundederror PFAs and QFAs recognize all and only regular languages [24, 20, 21, 2]. But, boundederror AfAs can recognize some nonregular languages such as and [7]. Moreover, AfAs can be very succinct compared to PFAs and QFAs [28, 29], i.e., they can recognize a family of regular languages with boundederror by using only two states, but the number of states of boundederror PFAs or QFAs cannot be bounded for this family.
The class of languages recognized by PFAs with cutpoints is called stochastic languages [24]. QFAs recognize all and only stochastic languages with cutpoints [31, 34]. Similar to boundederror case, AfAs are more powerful than both, and they can recognize some nonstochastic languages [7]. On the other hand, in the nondeterministic setting (when the cutpoint is fixed to zero), QFAs and AfAs have the same computational power [7].
Regarding the limitations on the computational power of AfAs, we know that [27, 32, 29, 16]:

(onesided or twosided) boundederror rationalvalued and integervalued AfAs have the same computational power;

onesided boundederror rationalvalued AfAs cannot recognize any nonregular unary language;

algebraicvalued AfAs cannot recognize certain nonstochastic unary languages in even with unboundederror (with cutpoints); and,

the class of languages recognized by boundederror rationalvalued AfAs is a proper subset of .
One open problem is whether boundederror rationalvalued AfAs can recognize any nonregular unary language, and, one untouched direction is the computational capabilities of realvalued AfAs.
1.2 The verification power of PFAs and QFAs
Interactive proof systems (IPSs) [12] with PFA verifiers [9] can verify some nonregular languages such as with bounded error. The same result is valid for IPS with QFA verifiers communicating with the prover classically.^{1}^{1}1When the proof system is fully quantum, we know little [23]: the restricted QFA model defined in [20] can verify only regular languages with boundederror. IPSs are also called privatecoin systems since a verifier can hide its probabilistic decisions from the prover. In this way, the verifier can use stronger verification strategies as a part of the protocol (between the verifier and prover) since the prover may not guess the exact configuration of the verifier, and so it may not easily mislead the verifier when it is not honest.
When the computation of a verifier is fully seen by the prover, the system is called publiccoin or AM system [3, 5]. AM system with PFA verifiers [6] cannot recognize any nonregular languages with bounded error, and we do not know whether AM systems with QFA verifiers can recognize any nonregular language with boundederror.
When considering the known results for AfAs (Section 1.1), there are two natural questions about the verification power of AM systems with rationalvalued AfA verifiers:

whether we can go beyond and, if so, how far, and,

whether some nonregular unary languages can be verified or not.
We answer both questions positively, and we obtain as the tight upper bound for nonunary languages.
1.3 Twoway PFAs and QFAs
As mentioned above, AfAs can recognize nonregular languages and with boundederror without interacting with any prover. Similar results can be obtained for PFAs and QFAs when reading the input many times by using a twoway head [10, 1]. We review basic facts about boundederror twoway PFAs and QFAs to have a better picture for our results on AfAs.
The language is recognized by boundederror twoway QFAs [1] in polynomial expected time and as well as by twoway PFAs [10] but only in exponential expected time [13].
The language can be recognized by boundederror twoway QFAs in exponential expected time [1], but it cannot be recognized in polynomial expected time even if twoway QFAs augmented with logarithmic amount of space [25]. On the other hand, AM systems with twoway PFA verifiers cannot verify with bounded error even if augmented with logarithmic space [9]. Besides, twoway boundederror PFAs can recognize only regular languages in polynomial expected time [8], and it is open whether AM systems with twoway PFAs can verify any nonregular languages in polynomial time.
Regarding unary languages, boundederror twoway PFAs cannot recognize any nonregular language [18], and it is open whether any unary nonregular language is verified by a boundederror AM system with twoway PFA verifier [6]. It is also open whether boundederror twoway QFAs can recognize any nonregular unary language.
The class of languages verified by AM systems with twoway rationalvalued PFA verifiers is a proper subset of [5]. Therefore, the verification power of AfAs can go beyond the verification power of twoway PFAs.
On the other hand, AM systems with twoway QFAs are very powerful [30, 26]. Twoway QFAs can verify every unary language in exponential expected time, and so their their verification power is equivalent to that of AfAs on unary languages. On nonunary languages, rationalvalued twoway QFAs can verify every language in and some NEXPcomplete languages. Therefore, AM systems with rationalvalued AfAs are weaker than AM systems with rationalvalued twoway QFAs. Here, we should note that AfA verifiers read the input once, but twoway QFAs may run in exponential or doubleexponential expected time.
2 Preliminaries
Throughout the paper, refers to the norm; denotes the input alphabet not containing symbols ¢ and , respectively called the left and right endmarkers; is the set ; denotes the set of all strings defined on the alphabet including the empty string denoted ; and, for a given string , denotes the string . Moreover, for any string , is the length of , is the number of occurrences of symbol in , and, whenever , represents the th symbol of , where . For an automaton ,
represents the accepting probability of
on the input .A realtime automaton reads the given input symbol by symbol and from the left to the right. On each symbol, a realtime automaton can stay a fixed amount of steps. If there is no waiting steps, then it is called strict realtime. In this paper, we focus on only the strict realtime models. For every given input , it is fed as so that the automaton can make preprocessing and postprocessing while reading the symbols ¢ and .
An state affine system is represented by , and affine state of this system is represented by
dimensional vector:
satisfying that , where , similar to the amplitudes in quantum systems, is the value of the system being in state .
Any affine operator of this system is a linear operator represented by an dimensional matrix:
satisfying that for each column (the column summation is 1). When the operator is applied to the affine state , the new state is .
To retrieve information from the affine system, similar to the measurement operators of quantum system, we apply a weighting operator. When the affine state is weighted, the th state is observed with probability
If the system is restricted to have only the nonnegative real numbers, then it turns out to be a probabilistic system.
2.1 Finite automata with deterministic and affine states
Similar to finite automata with quantum and classical states (QCFA) [1], a finite automaton with deterministic and affine states (ADfA) is an state deterministic finite automaton having an state affine register, where . Let be the deterministic states and be the affine states, where is the standard basis in with all zeros except the th entry which is 1.
The computation is governed classically. During the computation, each transition of an ADfA has two parts: affine and classical parts.

Affine transition: For each pair of deterministic state and reading symbol, say , either an affine operator or a weighting operator is applied to the affine register.

Classical transition can be two types:

If an affine operator is applied, then the next classical state is determined based on .

If a weighting operator is applied, then the next classical state is determined based on , where is the measured affine state.

In this paper, we apply the weighting operator only after reading the whole input, and so, we keep the formal definition of the models simpler: a single transition updates both the classical and affine parts at the same time.
Formally, a ADfA with classical and affine states is a 8tuple
where

and are the set of states as specified above;

is the transition function described below;

and are the deterministic and affine initial states, respectively; and,

is the deterministic accepting state;

is the set of affine accepting state(s).
Let be the given input of length . The ADfA reads the input as from the left to the right and symbol by symbol. The computation of is traced by a pair called a configuration, where is the classic state and is the affine state. At the beginning of the computation, is in , where the affine state .
The transition function is defined as . Let be the configuration after the th step and . Then the new configuration is , where and .
After reading symbol, if the final classical state is not , then the input is rejected deterministically:
Otherwise, a weighting operator is applied and the input is accepted if an affine accepting state is observed. We denote the final state as . Then, the accepting probability by the affine part is
We remark that the ADfA defined here can be exactly simulated by the original model defined in [7] with affine states.
2.2 Affine automata verifiers
In this paper, we study only ArthurMerlin type of interactive proof systems where the verifiers are affine automata. In [6], ArthurMerlin systems with probabilistic finite automata verifier is defined as an automata having both nondeterministic and probabilistic states. We follow the same framework here. We indeed give the ability of making nondeterministic transitions to ADfA models.
A finite automaton with nondeterministic and affine states (ANfA) with classical and affine states is formally a 8 tuples
where all elements are the same as ADfA except the transition function. For the pair , it can have one or more transitions:
where each pair can have a different value. When having more than one transition, picks each of them nondeterministically by creating a new path. In this way, forms a computation tree, where the root is the starting configuration. Remark that the computation in each path is the same as that of ADfAs and each path may have a different accepting probability. Each path here refers to the communication with a different prover.
2.3 Language recognition and verification
A language is said to be recognized by an ADfA with error bound , if

for every , , and

for every , .
Shortly, we can also say that is recognized by with bounded error or is recognized by a boundederror ADfA.
A language is said to be verified by an ANfA with error bound , if

for every , there is path on which , and

for every , on each path.
Shortly, we can also say that is verified by with bounded error or is verified by a boundederror ANfA.
2.4 Language classes
We define as the class of languages verifiable by boundederror ArthurMerlin system having realtime affine finite verifiers. Any language verifiable by a boundederror ANfA is in this class, and we obtain all results in this paper by ANfAs. Remark that a model of
realtime affine finite verifiers is more general than ANfA as applying weighting operators more than once and the outcomes can also be processed classically.
If the verifier is a PFA, QFA, twoway PFA, or twoway QFA, then the related class is , , , or , respectively, where 2QCFA is the twoway QFA model defined in [1].
We denote an AM class where the verifiers are restricted to have rationalvalued or integervalued components by using subscript or : or .
Here is the list of standard complexity classes mentioned in the paper:
:  regular languages  
:  logarithmic space  
:  polynomial time  
:  nondeterministic polynomial time  
:  linear space  
:  polynomial space  
:  nondeterministic exponential space  
:  all languages 
Lastly, for a given complexity class , denotes its unary version.
3 Basic computation with integervalued operators
In this section, we review some basic computation techniques by integervalued affine states and operators, which are later used in our proofs. We use the induction to verify the correctness of encoding techniques.
3.1 Binary encoding
We read a binary string and encode its numeric value as the value of an affine state.
We use three affine states. We start in the affine state , and, after reading , the affine state is set to
where is the numeric value of encoded in the value of . For symbol , we use the affine operator as described below:
Basis step: If the first symbol is , the new affine state is
where the values of and are 0. If the first symbol is , the new affine state is
where the values of and are 1 and , respectively.
Induction step: After reading the th symbol, we assume that the affine state is
where is numeric value of . If the th symbol is 0, the new affine state is
where we can observe that . Similarly, if the th symbol is 1, the new affine state is
where we can observe that .
3.2 Linear counting
We read the string and encode as the value of an affine state. We present two different methods.
Method 1: We start in the affine state , and, for each symbol , we apply the affine operator
After reading symbols, the affine state is
where is encoded in the value of .
Basis step: After reading one symbol:
where the value of is .
Induction step: When in , we calculate :
where the value of is .
Method 2: We start in the affine state , and, for each symbol , we apply the following operator:
After reading symbols, the affine state is
where is encoded in the value of .
Basis step: After reading one symbol:
where the value of is .
Induction step: When in , we calculate :
where the value of is .
3.3 Calculating
We read the string and encode as the value of an affine state. This can be done in many different ways.
One trivial solution is directly using the methods in Section 3.2. For example, we know that
If we use tensor the affine part with itself, we obtain
as the value of :If we use the first method in Section 3.2, then the dimension of the new affine vector is 9.
An alternative method is using binomial expansions, i.e., is a linear combination of such that . Thus, by using , , , we can calculate by a linear operator.
There are different ways of implementing this idea. The first one is that the affine state is of the form
after reading s, and then the corresponding affine operator (for symbol ) is
Here , and we can check the induction step as
which is equivalent to
One may also use the following forms of ’s:
In the latter form, 1 is eliminated, which is always obtained as the summation of the vector. The corresponding affine operators are accordingly:
We present the induction step for the latter form. The initial vector is , and the vector after th step is
which is, after the rearrangement of the first entry,
3.4 Calculating polynomials
Now, we generalize the method given in Section 3.3 using binomial expansions. Let be a polynomial with degree . Then, the set of variables is . Our aim is to have as the value of an affine state after applying the same affine operator times.
We read the string and encode as the value of an affine state as follows:
where is a variable making the column sum equal to 1.
We know that is a linear combination of , and is a linear combination of . We define the affine operator for symbol as a combination of two affine operators. The first affine operator updates the first entries by using binomial coefficients, and, the second affine operator calculates the value of polynomial by using the coefficients of the polynomial:
4 Verification of every unary language
Let be an arbitrary unary language, where . We define a real number to encode the whole membership information of as follows:
where

if and

if .
In binary form: . Moreover, we define
where .
We observe a few basic facts about and , which we will use in our proofs.

For any , there is a unary language such that .

The values of and so are bounded:

The values of and can be related:

If , then

If , then

By using , we design a boundederror ANfA for language . The main idea of the protocol is that each is nondeterministically guessed and the verification is done by subtracting the guessed and the actual value encoded in . As long as the nondeterministic choices are correct, the result of such subtractions will be zero. Otherwise, it will not be zero, based on which we reject the input. The details are given in the proof below.
Theorem 4.1
Every unary language is verified by an ANfA with error bound .
Proof
The verifier has two classical states and three affine states, where is the classical accepting state and is the only affine accepting state. The initial affine state is .
Let be the given input for . Until reading , makes two nondeterministic transitions for each symbol: for (), guesses the value of , say . If , then classical state is set to , and if , then classical state is set to . The affine operators are described below.
On symbol ¢, a combination of two affine operators is applied. In the first part, the affine state is set as
In the second part, the affine operator is applied, where
On each symbol , the second part for symbol ¢ is repeated: the affine operator is applied on the path where is picked.
If is guessed correctly, then affine state becomes
It is sufficient to check the value of :

If , after applying , the value of second entry becomes , which is equal to .

If , after applying , the value of second entry becomes , which is equal to .
Similarly, as long as the nondeterministic guesses are correct, the affine part evolves as given below:
Now, we examine the case in which at least one nondeterministic guess is wrong. Assume that is the first wrong guess (for symbol ). The value of is before this guess, and it becomes
after the guess. Thus, the absolute value of is bounded below by , which is at least 30 times greater than any . If there is another symbol to be read, then the value of is multiplied by 32 followed by subtraction of 0 or 1. That means the integer part of the absolute of new value of becomes greater than 30, and so the absolute value of is at least 900 times greater than any . For each new symbol of , this factor (i.e., 30 and 900) will be multiplied by 30.
On symbol , does not change the classical state and applies the following operator to the affine state:
where , which gives the minimum error when maximizing the accepting probability for members and minimizing the same for the nonmembers.
If , the path following the correct nondeterministic guesses ends in classical state and affine state . Remember that . Thus, the input is accepted with probability
If , then we have different cases. (1) If is guessed correctly (), then the input is rejected deterministically. (2) If each guess is correct except (), then affine state is
and so, the accepting probability is
In other words, the rejecting probability is at least . (3) If the guess for is wrong, then, as we described above, the absolute values of and are at least 30 times bigger than that of the case (2), and so is the rejecting probability. ∎
When defining , the denominators can be some numbers greater than 32, and, in this way we can obtain better error bounds, i.e., arbitrarily close to 0.
Corollary 1
Every unary language is verified by ANfAs with arbitrarily small error bounds.
5
Recently, it was shown [16] that any language recognized by a rationalvalued ADfA with error bound is recognized by an integervalued ADfAs with error bound , where . The latter automaton is constructed by modifying the components of the former automaton so that, on the same input, the accepting probability of the latter one can differ insignificantly from the accepting probability of the former one, i.e., the difference is at most . Thus, on the same input, the accepting probabilities for the same nondeterministic path will differ insignificantly, and so the error bound increases but still less than .
Theorem 5.1
.
It is known that [6]. We do not know whether contains any nonregular language. On the other hand, ADfAs can recognize some nonregular languages with boundederror such as requiring at least logarithmic space for boundederror probabilistic computation [11]. A natural question is whether goes beyond .
Theorem 5.2
.
Proof
Let be a language. Then, there is an ANfA verifying with error bound .
The descriptions of
and the error bound are finite, which can be wired into the description of Turing Machines (TMs). For any given input, the computation on each path of
can be traced by vector and matrix multiplications. As the length of each sequence is linear, all computation including weighting, calculating the accepting probability, and comparing it with the error bound can be done in polynomial time and linear space (i.e., the size of affine state vector is fixed, the precision of each entry can be at most linear, and each new entry is a linear combination of these entries).In the case of nondeterministic TM simulation, the TM implements the nondeterministic choices of directly. In the case of linearspace TM simulation, the TM use a linear counter to check all nondeterministic strategies onebyone. Even though the overall simulation runs in exponential expected time, the space usage can be bounded linearly. ∎
We show that integervalued ANfAs can verify some NPcomplete problems. For this purpose, we use the following language version of the Knapsack problem (Page 491 of [19]): is the language of strings of the form , where

are binary numbers and

there exists a subset of that adds up to precisely , i.e.,
Remark that we do not use any nonnegative integer, and it is still NPComplete.
Theorem 5.3
is verified by an integervalued ANfA such that every member is accepted with probability 1 and every nonmember is accepted with probability at most for some .
Proof
Let , where . The verifier , shortly , classically checks has at least one . Otherwise, the input is rejected deterministically.
In the remaining part, we assume that is of the form for some . Remark that the binary value of empty string is zero (whenever or any ). The protocol has the following steps:

starts with encoding into the value of affine state .

nodeterministically picks some ’s (). Such decision is made when reading symbols .

If is not picked, then affine state does not changed.

Otherwise, encodes into the value of the affine state , and then, it is subtracted from the value of and the value of is set to zero.


At the end of the computation, the decision is made based on the fact that the value of is zero for the members and nonzero integer for the nonmembers. The error is reduced by using certain tricks before the weighting operator.
The affine part has four states and is the only accepting state. The initial affine state is , and it does not change when reading ¢. For encoding binary string, we use the technique described in Section 3.1. The value of is encoded by using the affine operators :
where the value of is not changed. The value of each picked is encoded by the affine operators :
where the value of is not changed. With the following operator, the value of is subtracted from the value of and set to 0:
For a picked subset , let . Before weighting operator, for some , we apply the following operator to decrease the error bound for the nonmembers:
On the path where is followed, just before applying , the affine state is
and it is
after applying . It is easy to see that if , then the final affine state is and so the input is accepted with probability 1. If , then , and so the values of and are not zero and the accepting probability can be at most .
Therefore, if , then there exists a subset satisfying the membership condition and it is picked on a path where the input is accepted with probability 1. If , there is no subset satisfying the membership condition, and so the input is accepted with probability at most in each path. The error bound can be arbitrarily small when . ∎
It is not known that whether there is a NPComplete unary language or not. It was shown that if there is such a language, then [4]. Regarding the verification power of rationalvalued ANfAs, we use some nonstochastic unary languages.
For a given nonlinear polynomial with nonnegative integer coefficients , we define a unary language as . Turakainen [27] showed that such languages are not stochastic. Recently, it was shown that [16] they are not algebraic affine languages, too, i.e., they cannot be recognized by algebraicvalued ADfAs with cutpoints.
Now, we show that ANfAs can verify any language with bounded error. We start with a very simple case: .
Theorem 5.4
Language is verified by an ANfA with any error bound , where .
Proof
We use the parameter at the end of the proof, and we represent shortly as . The verifier uses affine states, and is the single accepting affine state. Let be the given input. If , then it is accepted classically. We assume that in the rest of the proof.
The protocol of is as follows: nondeterministically picks a positive integer and then checks whether . If , then there exists such and so this comparison is made successfully in one of the nondeterministic paths. If , there is no such and so there is no successful comparison in any nondeterministic path.
The verifier follows different paths during its computation:
where the main one is . We use the encoding techniques given in Section 3.2 and 3.3. When reading the th symbol of , continues with or creates .
On , is in the following affine states after reading and :
respectively. After reading , creates , on which it is in the affine state
For the rest of the computation, continues with counting the number of symbols on but it does not change the value of until reading . The affine state on () after reading is
On , the input rejected is classically. On , after reading , enters the classical accepting state, and it sets the affine state as
If , then on