Affine automata verifiers

04/22/2021
by   Aliya Khadieva, et al.
University of Latvia
0

We initiate the study of the verification power of AfAs as part of Arthur-Merlin (AM) proof systems. We show that every unary language is verified by a real-valued AfA verifier. Then, we focus on the verifiers restricted to have only integer-valued or rational-valued transitions. We observe that rational-valued verifiers can be simulated by integer-valued verifiers, and, their protocols can be simulated in nondeterministic polynomial time. We show that this bound tight by presenting an AfA verifier for NP-complete problem SUBSETSUM. We also show that AfAs can verify certain non-affine and non-stochastic unary languages.

READ FULL TEXT VIEW PDF

page 1

page 2

page 3

page 4

07/13/2018

Postselecting probabilistic finite state recognizers and verifiers

In this paper, we investigate the computational and verification power o...
09/05/2019

The Complexity of Reachability in Affine Vector Addition Systems with States

We give a trichotomy on the complexity of integer reachability in vector...
10/04/2020

All-Pass Filters for Mirroring Pairs of Complex-Conjugated Roots of Rational Matrix Functions

In this note, we construct real-valued all-pass filters for mirroring pa...
07/22/2020

Rational points on complete symmetric hypersurfaces over finite fields

For any affine hypersurface defined by a complete symmetric polynomial i...
07/06/2022

On the Complexity of Rational Verification

Rational verification refers to the problem of checking which temporal l...
10/18/2021

Finite Sections of Periodic Schrödinger Operators

We study discrete Schrödinger operators H with periodic potentials as th...
06/27/2019

A Simultaneous Transformation and Rounding Approach for Modeling Integer-Valued Data

We propose a simple yet powerful framework for modeling integer-valued d...

1 Introduction

Affine finite automata (AfAs) are quantum-like 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 non-linear.

AfAs was formally defined in [7], and it was shown that they are more powerful than PFAs and quantum finite automata (QFAs) in bounded-error and unbounded-error 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 Arthur-Merlin (AM) proof systems. We show that every unary language is verified by a real-valued AfA verifier. Then, we focus on the verifiers restricted to have only integer-valued or rational-valued transitions. We observe that rational-valued verifiers can be simulated by integer-valued verifiers, and, their protocols can be simulated in nondeterministic polynomial time. We show that this bound tight by presenting an AfA verifier for NP-complete problem . We also show that AfAs can verify certain non-affine and non-stochastic unary languages. In our protocols, we use similar verification strategies and encoding techniques previously used for two-way 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 integer-valued 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 integer-valued 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.

Bounded-error PFAs and QFAs recognize all and only regular languages [24, 20, 21, 2]. But, bounded-error 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 bounded-error by using only two states, but the number of states of bounded-error 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 bounded-error case, AfAs are more powerful than both, and they can recognize some non-stochastic 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]:

  • (one-sided or two-sided) bounded-error rational-valued and integer-valued AfAs have the same computational power;

  • one-sided bounded-error rational-valued AfAs cannot recognize any nonregular unary language;

  • algebraic-valued AfAs cannot recognize certain non-stochastic unary languages in even with unbounded-error (with cutpoints); and,

  • the class of languages recognized by bounded-error rational-valued AfAs is a proper subset of .

One open problem is whether bounded-error rational-valued AfAs can recognize any nonregular unary language, and, one untouched direction is the computational capabilities of real-valued 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.111When the proof system is fully quantum, we know little [23]: the restricted QFA model defined in [20] can verify only regular languages with bounded-error. IPSs are also called private-coin 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 public-coin 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 bounded-error.

When considering the known results for AfAs (Section 1.1), there are two natural questions about the verification power of AM systems with rational-valued AfA verifiers:

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

  2. whether some nonregular unary languages can be verified or not.

We answer both questions positively, and we obtain as the tight upper bound for non-unary languages.

1.3 Two-way PFAs and QFAs

As mentioned above, AfAs can recognize nonregular languages and with bounded-error without interacting with any prover. Similar results can be obtained for PFAs and QFAs when reading the input many times by using a two-way head [10, 1]. We review basic facts about bounded-error two-way PFAs and QFAs to have a better picture for our results on AfAs.

The language is recognized by bounded-error two-way QFAs [1] in polynomial expected time and as well as by two-way PFAs [10] but only in exponential expected time [13].

The language can be recognized by bounded-error two-way QFAs in exponential expected time [1], but it cannot be recognized in polynomial expected time even if two-way QFAs augmented with logarithmic amount of space [25]. On the other hand, AM systems with two-way PFA verifiers cannot verify with bounded error even if augmented with logarithmic space [9]. Besides, two-way bounded-error PFAs can recognize only regular languages in polynomial expected time [8], and it is open whether AM systems with two-way PFAs can verify any nonregular languages in polynomial time.

Regarding unary languages, bounded-error two-way PFAs cannot recognize any nonregular language [18], and it is open whether any unary nonregular language is verified by a bounded-error AM system with two-way PFA verifier [6]. It is also open whether bounded-error two-way QFAs can recognize any nonregular unary language.

The class of languages verified by AM systems with two-way rational-valued PFA verifiers is a proper subset of [5]. Therefore, the verification power of AfAs can go beyond the verification power of two-way PFAs.

On the other hand, AM systems with two-way QFAs are very powerful [30, 26]. Two-way 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 non-unary languages, rational-valued two-way QFAs can verify every language in and some NEXP-complete languages. Therefore, AM systems with rational-valued AfAs are weaker than AM systems with rational-valued two-way QFAs. Here, we should note that AfA verifiers read the input once, but two-way QFAs may run in exponential or double-exponential 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 end-markers; 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 pre-processing and post-processing 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 non-negative 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.

  1. 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.

  2. Classical transition can be two types:

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

    2. 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 8-tuple

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 Arthur-Merlin type of interactive proof systems where the verifiers are affine automata. In [6], Arthur-Merlin 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 bounded-error 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 bounded-error ANfA.

2.4 Language classes

We define as the class of languages verifiable by bounded-error Arthur-Merlin system having realtime affine finite verifiers. Any language verifiable by a bounded-error 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, two-way PFA, or two-way QFA, then the related class is , , , or , respectively, where 2QCFA is the two-way QFA model defined in [1].

We denote an AM class where the verifiers are restricted to have rational-valued or integer-valued 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 integer-valued operators

In this section, we review some basic computation techniques by integer-valued 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 re-arrangement 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.

  1. For any , there is a unary language such that .

  2. The values of and so are bounded:

  3. The values of and can be related:

    • If , then

    • If , then

By using , we design a bounded-error 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 non-members.

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 rational-valued ADfA with error bound is recognized by an integer-valued 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 non-regular language. On the other hand, ADfAs can recognize some non-regular languages with bounded-error such as requiring at least logarithmic space for bounded-error 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 linear-space TM simulation, the TM use a linear counter to check all nondeterministic strategies one-by-one. Even though the overall simulation runs in exponential expected time, the space usage can be bounded linearly. ∎

We show that integer-valued ANfAs can verify some NP-complete 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 non-negative integer, and it is still NP-Complete.

Theorem 5.3

is verified by an integer-valued ANfA such that every member is accepted with probability 1 and every non-member 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:

  1. starts with encoding into the value of affine state .

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

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

    2. 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.

  3. At the end of the computation, the decision is made based on the fact that the value of is zero for the members and non-zero integer for the non-members. 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 non-members:

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 NP-Complete unary language or not. It was shown that if there is such a language, then [4]. Regarding the verification power of rational-valued ANfAs, we use some non-stochastic unary languages.

For a given non-linear polynomial with non-negative 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 algebraic-valued 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