Log In Sign Up

Nonuniform Families of Polynomial-Size Quantum Finite Automata and Quantum Logarithmic-Space Computation with Polynomial-Size Advice

by   Tomoyuki Yamakami, et al.

The state complexity of a finite(-state) automaton intuitively measures the size of the description of the automaton. Sakoda and Sipser [STOC 1972, pp. 275-286] were concerned with nonuniform families of finite automata and they discussed the behaviors of nonuniform complexity classes defined by families of such finite automata having polynomial-size state complexity. In a similar fashion, we introduce nonuniform state complexity classes using families of quantum finite automata. Our primarily concern is one-way quantum finite automata empowered by garbage tapes. We show inclusion and separation relationships among nonuniform state complexity classes of various one-way finite automata, including deterministic, nondeterministic, probabilistic, and quantum finite automata of polynomial size. For two-way quantum finite automata equipped with garbage tapes, we discover a close relationship between the nonuniform state complexity of such a polynomial-size quantum finite automata family and the parameterized complexity class induced by quantum logarithmic-space computation assisted by polynomial-size advice.


page 1

page 2

page 3

page 4


How Does Adiabatic Quantum Computation Fit into Quantum Automata Theory?

Quantum computation has emerged as a powerful computational medium of ou...

Behavioral Strengths and Weaknesses of Various Models of Limited Automata

We examine the behaviors of various models of k-limited automata, which ...

Quantum Finite Automata and Quiver Algebras

We find an application in quantum finite automata for the ideas and resu...

Planning in POMDPs Using Multiplicity Automata

Planning and learning in Partially Observable MDPs (POMDPs) are among th...

Conscious enactive computation

This paper looks at recent debates in the enactivist literature on compu...

1 Prelude: Quick Overview

This exposition reports a collection of fundamental results obtained by an early study on the state complexity of nonuniform families of quantum finite automata, which is briefly referred to as the nonuniform state complexity throughout this exposition.

1.1 Nonuniform State Complexity of Finite Automata Families

Each finite(-state) automaton is completely described in terms of a set of transitions of its inner states because there is no memory device, such as a stack, a work tape, etc. The number of inner states is thus crucial to measure the descriptional size of the automaton in question and it works as a complexity measure, known as the state complexity of the automaton. This complexity measure therefore naturally serves as a clear indicator for the computational power of the automaton. Instead of taking a single automaton, in this exposition, we consider a “family” of finite automata in a way similar to taking a family of Boolean circuits. Such a family of finite automata may be generated individually by a certain fixed deterministic algorithm in a uniform setting. Unlike Boolean circuits, nevertheless, inputs of automata are not limited to certain fixed lengths and this situation provides an additional consideration for simulation of automata. For brevity, the term “uniform sate complexity” refers to the state complexity of such a uniform family of finite automata. Opposed to this uniform state complexity, here we intend to study its “nonuniform” counterpart, known under the name of nonuniform state complexity. This nonuniform complexity measure has turned out to be closely related to a nonuniform model of Turing-machine computations.

In the past literature, nonuniform state complexity has played various roles in automata theory. An early discussion that attempted to relate certain state complexity issues to the collapses of known space-bounded complexity classes dates back to late 1970s. Sakoda and Sipser [29], following Berman and Lingas [4], argued on the state complexity of transforming one family of 2-way nondeterministic finite automata (or 2nfa’s, for short) into another family of 2-way deterministic finite automata (or 2dfa’s). From their works, we have come to know that the state complexity of a family of automata is closely related to the work-tape space usage of a Turing machine. In this line of study, after a long recess, Kapoutsis [19] and Kapoutsis and Pighizzini [20] lately revitalized a discussion on the relationships between logarithmic-space (or log-space, for short) complexity classes and state complexity classes in connection to the question (in fact, the question, where is the nonuniform analogue of ).

Taking a complexity-theoretic approach, Kapoutsis [17, 18] earlier discussed relationships among the nonuniform state complexity classes , , , and of families of “promise” decision problems, each of which is solved by a nonuniform family of deterministic and nondeterministic finite automata of polynomially many inner states (see Section 2 for their definitions). Along the same line of study, Yamakami [49] recently gave a characterization of the polynomial-time sub-linear-space “parameterized” complexity class, known as , and an -complete problem parameterized by the number of vertices of an input graph (which is generally referred to as a size parameter) in terms of the state complexities of restricted 2nfa’s and narrow 2-way alternating finite automata (abbreviated as 2afa’s).

An important discovery of [49] is the fact that a nonuniform family of promise decision problems is more closely related to parameterized decision problems than “standard” decision problems (whose complexities are measured by the binary encoding size of inputs). A decision problem (identified with a language) over an alphabet and a reasonable size parameter from to (the set of all natural numbers) form a parameterized decision problem [47]. We can naturally translate such a parameterized decision problem into a uniform family of promise decision problems and also translate back into another parameterized decision problem , which is “almost” the same as . See Section 2.4 for more details. These translations between parameterized decision problems and families of promise decision problems play an essential role in this exposition. For notational readability, we use the special prefix “para-” and write, for example, and to denote respectively the parameterized analogues of and .

After the study of state complexity classes was initiated in [29], a further elaboration has been long anticipated; however, there has been little research on how to expand the scope of these classes. Our purpose of this exposition is to enrich the world of nonuniform state complexity classes toward a whole new direction.

1.2 An Extension to Quantum Finite Automata

We intend to expand the scope of nonuniform state complexity theory to an emerging field of quantum finite automata. The behaviors of quantum finite automata, viewed as a natural extension of probabilistic finite automata, are governed by quantum physics. Moore and Crutchfield [26] and Kondacs and Watrous [25] modeled the quantumization of finite automata in two quite different ways. Lately, these definitions have been considered insufficient for implementation and advantages over classical finite automata and, for this reason, numerous generalizations have been proposed (see, e.g., a survey [3] for references). Here, we intend to use two distinct models: measure-many 1-way333We use this term “1-way” in a strict sense that a tape head always moves to the right and is not allowed to stay still on the same cell. This term is called “real time” in certain literature. quantum finite automata with garbage tapes (or 1qfa’s, for short) and measure-many 2-way quantum finite automata with garbage tapes (or 2qfa’s), where garbage tapes are write-only tapes used to discard unwanted information, which is considered to be released into an external environment surrounding the target quantum finite automata. For an early use of tape tracks to discard the unnecessary information, see [44, Section 5.2]. The above models are simple to describe with no additional use of mixed states, superoperators, classical inner states, etc. and they are also as powerful as the generalized models cited in [16, 38]. This last claim will be examined later in Lemma 2.1.

1.3 Overview of Main Contributions

In analogy to and , we introduce their probabilistic and quantum variants in the following manner. We write for the collection of families , each of which is solved by a certain 1qfa of polynomially-bounded garbage alphabet size with unbounded-error probability using polynomially many inner states. If we relax the unbounded-error requirement to the bounded-error requirement (i.e., error probability is bounded from above by a certain constant in ), we write in place of . Similarly to Boolean circuits, we often limit the length of input strings fed to given finite automata. Furthermore, if we replace quantum finite automata by probabilistic finite automata, then we obtain and from and , respectively. By allowing 1dfa’s to have states for a certain polynomial , we obtain from . Using the 2-way models insetad, we naturally obtain and from and , respectively. The nonuniform state complexity class is introduced in a way similar to but using bounded-error 2qfa’s instead of bounded-error 1qfa’s. When nondeterministic quantum computation is used, however, we obtain . There are a few known separations: , [17, 18], and [17]. We also obtain from [9, Theorem 6.1] and from [9, Theorem 6.2].

The first part of our main result is summarized in Figure 1. New inclusions and separations in this figure are proven in Theorems 3.1 and 4.2(1).

Figure 1: Inclusion/separation relationships among nonuniform state complexity classes

We consider a restricted form of 2qfa’s. When the input size of each string in is limited to at most for a certain fixed polynomial , we write and instead of and , respectively. We show the following close connections between advised complexity classes and nonuniform state complexity classes.

When we handle probabilistic and quantum finite automata, it is of significant importance to discuss the expected runtime of these machines. From execution efficiency concern, it is reasonable for us to concentrate on 2qfa’s running in expected polynomial time rather than 2qfa’s with no time bounds. Let us consider a family of 2qfa’s whose expected runtime is restricted to a certain polynomial in the index of . To emphasize the expected polynomial runtime, we append the prefix “ptime-” as in and . Similarly, for QTMs running in expected polynomial time, we emphasize this runtime bound by the prefix “ptime-” as in and . For deterministic/nondeterministic computation, we note that , , , and . In Theorem 4.2(2), we present two extra inclusions: and .

To introduce the nonuniformity notion into a model of quantum Turing machine (or QTM, for short), we equip QTMs with the Karp-Lipton style advice as supplemental external information to empower those underlying QTMs (see, e.g., [28]).

Theorem 1.1

Let with . It then follows that iff , where, when , “” is understood as “.”

Corollary 1.2
  1. iff .

  2. iff .

Theorem 1.1 follows from the exact characterizations (Proposition 5.1) of parameterized complexity classes in terms of nonuniform state complexity classes, and vice versa. This proposition helps us translate nonuniform state complexity classes, such as , , , and , into their corresponding advised parameterized complexity classes, , , , and , where the last class , for example, denotes the collection of parameterized decision problems solvable by bounded-error QTMs in polynomial time in using work tapes of space logarithmic in with (deterministic) advice of size polynomial in (see Section 2.4 for their precise definitions).

Nishimura and Yamakami [28] introduced the notion of quantum advice to enhance the ability of polynomial-time QTMs. Quantum advice manifests a quantumization of randomized advice (see, e.g., [42, 43]). To emphasize the use of quantum advice, we write in accordance with [28]. As discussed in [44], the rewriting of an advice tape provides extra power for quantum finite automata. We thus allow a memory-limited QTM to “erase” advice symbols just before its termination to make appropriate quantum interference to take place. This erasing process is quite crucial in the use of quantum advice in quantum computation unless an underlying machine uses sufficient memory space. In parallel to the change of deterministic advice to quantum advice, we also modify our basic model of 2qfa’s as follows. Firstly, we express a (quantum) transition function as the form of a matrix or a table, which can be easily encoded into a string over a certain alphabet. For readability, we use the term “transition table” to address this encoded string. See Section 2.2 for the precise definition. This encoding further makes it possible to consider a superposition of transition tables. Generally, we call by a super quantum finite automaton a quantum finite automaton obtained by substituting superpositions of transition tables for a quantum transition function. We further demand a mechanism of “erasing” its transition tables before terminating. For convenience, we use the notion to express the nonuniform state complexity class obtained from by substituting super 2qfa’s for ordinary 2qfa’s.

Theorem 1.3

iff .

A further study on relativizations (or Turing reducibility) was lately conducted in [50].

As the final remark, we note that it is possible to consider the uniform version of nonuniform state complexity classes that we discuss in this exposition.

2 Preparations: Basic Notions and Notation

Let , , , and denote respectively the sets of all natural numbers (i.e., nonnegative integers), of all integers, of all rational numbers, and of complex numbers. Given two integers with , denotes the integer interval, which is the set . Let . All polynomials in this exposition are assumed to have nonnegative integer coefficients. Assume that the logarithms are always to base . Let be any alphabet, which is a finite nonempty set. A string over is a finite sequence of symbols in ; in particular, we use the notation to denote the empty string of length . A language over is a set of strings over . We freely identify a language with its characteristic function; that is, for all and for all . Given a size-bounding function , a function is called -bounded if holds for all .

2.1 Computational Models of Finite Automata

Our finite automata are always equipped with read-only input tapes, which use two endmarkers (left endmarker) and (right endmarker), where a given input string is written initially in between the two endmarkers. In contrast, each Turing machine is equipped with a read-only input tape with the two endmarkers and as well as a rewritable work tape. Occasionally, we further equip a Turing machine with a read-only advice tape, which holds a given advice string, together with the two endmarkers. It is important to note that no machine modifies a given advice string during its computation (except for the quantum advice model in Section 6).

For clarity reason, we use the term “one way” only to refer to the condition of a given machine where its tape head always moves to the right without stopping (i.e., there is no -move). On the contrary, if we allow such “-moves,” we instead use the term “1.5 way” to emphasize its difference from “one way” head moves.

We assume the reader’s familiarity with the basics of quantum computation (see, e.g., [15, 27]). Since Kondacs and Watrous’s model of 1qfa’s [25] is strictly weaker in power than 1dfa’s, there have been numerous generalizations proposed in the literature (see, e.g., a survey [3]). As one of such generalizations, we here empower their 1qfa’s by simply equipping each of them with a write-only garbage tape in which a machine drops any symbol (called a garbage symbol) but never accesses any non-blank symbol written on the tape again. An early idea of 1qfa’s discarding garbage information down to a portion of a read-once input tape was materialized in [44] and such a mechanism was shown to enhance the computational power of 1qfa’s. Yakaryilmaz, Freivalds, Say, and Agadzanyan [36] also discussed write-only memory. The use of a garbage tape allows us to make 1qfa’s simulate all 1dfa’s. Each tape has the left endmarker , and input and advice tapes additionally have the right endmarker . All tape cells are indexed by numbers in ; in particular, is always placed in cell .

Formally, a 1-way quantum finite automaton with a garbage tape (where we hereafter use the term “1qfa” to indicate this particular model unless otherwise stated) is a tuple , where is a finite set of inner states, is an input alphabet, is a garbage alphabet, is a (quantum) transition function mapping to , () is the initial inner state, and are subsets of , where and . All inner states in are called halting states and the rest of inner states are non-halting states. Let and denote respectively the Hilbert spaces spanned by all halting states and by all non-halting states. The garbage tape can be considered as a surrounding environment that exists “externally,” separated from the essential part of a computation. By observing the garbage tape at every step produces a mixed state of “internal” configurations of and therefore, our model turns out to be as powerful as other generalized models of 1qfa’s given in [16, 38], which allow 1qfa’s to use mixed states and superoperators (see, e.g., a survey [3] for references therein). For completeness, we will prove this claim in Lemma 2.1.

Similarly, we define a 2-way quantum finite automaton with a garbage tape (or a 2qfa, for short) by allowing a tape head to move in both directions as well as stay still (equivalently, make a stationary move). To be more formal, a 2qfa is of the form with a transition function . We treat 1qfa’s as a special case of 2qfa’s.

A configuration of a 2qfa is a tuple , where , , , and a garbage-tape content

. This describes a “snapshot” at a certain moment of the machine’s internal condition where

is in inner state , its input-tape head stays in the th tape cell, and the garbage tape contains . The function naturally induces the time-evolution operator of on input , which is defined as follows. First, we define as

where each is the th symbol of with and . When is fixed, we often remove and consider a surface configuration ; in this case, we write instead of . Let denote the projection measurement onto the space . At each step, we first apply and then perform a measurement by applying . If we observe an accepting (resp., rejecting) configuration, then we accept (resp., reject) the input . Otherwise, we continue to the next step.

We say that is well-formed if is a unary matrix for all . In the rest of this exposition, we assume that all 1qfa’s as well as 2qfa’s are well-formed. Notice that the expected runtime of each 2qfa varies.

The use of garbage tapes provides sufficiently high computational power to underlying 1qfa’s and it also makes 1qfa’s equivalent in power to generalized 1qfa’s that allow mixed states and superoperators, as implicitly shown below. Notice that such generalized 1qfa’s recognize exactly regular languages. For the sake of completeness, we include the proof of the next lemma.

Lemma 2.1

Any -state bounded-error 1qfa with a garbage alphabet of size can be simulated by a certain -state 1dfa.


Let be any alphabet and let be any error bound. Take an -state 1qfa with a garbage alphabet of size with error probability at most . We follow an argument similar to [3]. We simulate classically as follows. Let be a set of all inner states of and set . Let be any input in . Consider two Hilbert spaces and . For convenience, write for the set . We then define the unit sphere as .

Consider superpositions of surface configurations of on . Let . For each , let , where is a normalizing nonzero constant. We consider a density operator . Since is of dimension , we can express as

for appropriate vectors

and numbers for each .

Consider the space . A set of vectors in is called an -net if, for any , there exists a vector satisfying . For each space , by the Solovay-Kitaev theorem (e.g., [23, 27]), there is an -net, say, of vectors. Therefore, there is an -net of () vectors for . ∎

2.2 Transition Tables

The behavior of a 2qfa is dictated by its transition function . However, it is sometimes convenient to use the notion of “transition tables,” which is just another way to describe , introduced in [49, arXiv version] to establish a close tie between nonuniform state complexity and a working hypothesis, known as the linear space hypothesis. A transition table is a “description” of , which can be expressed as a (classical) string. In [49, arXiv version], each row of a transition table is indexed by elements in , each column is indexed by elements in , and the -entry of the table contains if ; otherwise. Although this definition is valid for deterministic/nondeterministic finite automata, we cannot use the same one for 2qfa’s because we need to deal with a set of quantum transition amplitudes, which are generally arbitrary complex numbers. Hence, we need to find an appropriate way of encoding transition amplitudes of each 2sqfa into our transition table.

Let be a 2qfa of the form with and of constant sizes. Since ’s transition amplitudes are complex numbers, we want to use a quantum circuit to generate those amplitudes and we then encode this quantum circuit into a transition table, where a quantum circuit is made up of finitely many quantum gates taken from a certain universal set. In the rest of this exposition, we fix as such a universal set, where is the Controlled-NOT, is the Hadamard transform, and is the -rotation around the axe (see, e.g., [27]).

Formally, we express inner states of as strings in , symbols in as strings in for two appropriate numbers and (thus, and ), and directions in as elements in . A transition table of on input is a matrix, each row of which is indexed by in , whose -row contains a “description” of a unitary matrix that, on input , produces a quantum state . Given any parameter , any input of length , and any pair , we intend to define a quantum circuit so as to approximate .

Assume that on input runs in expected time for a certain function and errors with probability at most a certain constant . It suffices to consider the first steps of for an appropriately chosen absolute constant to guarantee that the error probability obtained during these steps is still at most another constant , where . Under this circumstance, letting , we want to approximate with inaccuracy of by a certain quantum circuit made up of the aforementioned universal quantum gates; namely, . For convenience, we write for the machine obtained from by replacing each with .

Let denote the number of quantum gates in . An upper bound of is given by the following lemma.

Lemma 2.2

There is a constant for which any unitary matrix can be approximated by a certain

-qubit quantum circuit

of universal gates satisfying .


Given a unitary matrix , as in the same way described in [27, Section 4.5.1], we can take a number and 2-level unitary matrices yielding . In the same way as in [27, Section 4.5.2], we then decompose each 2-level unitary matrix into 1-qubit and CNOT gates, where 1-qubit gates may not be limited to . Combining them, we can realize by a quantum circuit of 1-qubit and CNOT gates. let be the number of used quantum gates. The Solovay-Kitaev theorem (e.g., [23, 27]) shows that, for , there exists a constant such that each 1-qubit gate can be approximated by universal gates from to within . By setting , we need universal gates to approximate since and . ∎

Since is a unitary matrix, Lemma 2.2 implies that is in since . We then express as a series , where and .

The quantum circuit can be specified by a series , and thus can be encoded into a string of the form , where , , and . Note that, when is written on a tape, it is possible to generate a quantum state by sweeping the tape from the left to the right and applying one by one. Let be a set of all approximated quantum circuits corresponding to . We first enumerate all elements in as , where , and, according to this enumeration, we set as . The length of is .

Since preforms at most applications of matrices , the quantum state produced by after steps can be approximated to within by the quantum state produced by after steps. This implies that the difference between the acceptance (resp., rejecting) probabilities between and is at most (see, e.g., [5, 40]). Therefore, if accepts (resp., rejects) with probability at least , then accepts (resp., rejects) with probability at least , which equals .

A family of transition tables is called polynomially bounded if the family of encoded strings of the transition tables is polynomially bounded.

2.3 Quantum Turing Machines with Advice

In accordance with the aforementioned quantum finite automata, we equip quantum Turing machines with garbage tapes. Since we discuss only such machines in later sections, we simply refer to quantum Turing machines equipped with garbage tapes as QTMs. A QTM has a work tape and a work alphabet (with a unique blank symbol ) as well. We further supplement a piece of useful information, known as “advice.” An advice function is a function from to for a certain alphabet , and each value is called an advice string. Since we need to handle such advice, we further supply the QTM with a distinguished advice tape. For convenience, we call a QTM with an advice tape by an advised QTM. Formally, an advised QTM is a tuple , including a work alphabet , an advice alphabet , and a garbage alphabet . We assume that ’s input tape is read only and, just before the termination, ’s advice tape should be cleared; that is, any symbol on the advice tape should be replaced by the blank symbol, say, .

A configuration of is a tuple , where , , , , , and . This configuration expresses a situation where is in state , scanning the th cell of an input tape, the th cell of a work tape, th cell of an advice tape containing , and a garbage tape containing . There is no need to include the head position of the garbage tape. The configuration space is spanned by all configurations of . When and are fixed throughout computation, we use a surface configuration of the form for simplicity. The time-evolution operator of such an advised QTM on the configuration space is defined in a similar way as a quantum finite automaton; that is,

where . We demand that the time-evolution operator of our QTM is unitary.

With the use of logarithmic work space, using one of the work tapes, we can implement an internal clock that helps quantum interference take place in a computation.

The advised quantum complexity class consists of languages, each of which is recognized by a certain QTM equipped with an advice tape and a polynomially-bounded advice function using only logarithmic space. In a similar manner, we define and using probabilistic Turing machines and nondeterministic Turing machines.

2.4 Parameterized Decision Problems and Promise Decision Problems

A size parameter is a function from to for a certain alphabet . Typical examples include (binary size of input ) and indicates the number of vertices in a graph . A parameterized decision problem over an alphabet is a pair with a language (equivalently, a decision problem) over and a size parameter . We define a useful translation between a parameterized decision problem and a family of promise decision problems. Given a parameterized decision problem , a family of promise decision problems is said to be induced from if, for each index , and , where .

On the contrary, let be a family of promise decision problems over an alphabet . We set . Note that is included in but it may not equal . With the use of a distinguished separator , we set . For each index , we define and . Furthermore, we set and . It follows that and . We define as follows: if for a certain , and otherwise. The pair turns out to be a parameterized decision problem. We say that is induced from .

A size parameter is said to be polynomially bounded if is -bounded for a certain polynomial ; in contrast, is polynomially honest if, for a certain fixed polynomial , holds for any . We use the notation to denote the set of all parameterized decision problems such that is polynomially-honest size parameters.

We say that is a log-space size parameter if there exists a deterministic Turing machine such that, for any string , takes as an input and produces on its write-only output tape using space [47]. Notice that the function is polynomially bounded because, otherwise, a log-space machine computing must stay in an infinite loop. Thus, is also polynomially bounded.

A promise decision problem is of the form over an alphabet satisfying both and . As stated in Section 1.1, we deal with a “family” of promise decision problems, having the form over a certain fixed alphabet . For such a family of promise problems and a given family of certain specified machines that satisfy appropriate criteria for acceptance and rejection, we generally say that recognizes (solves or computes) if (1) for any , accepts and, (2) for all , rejects . There is no requirement for the behavior of on any string outside of and possibly neither accepts nor rejects such an .

Consider a family of promise decision problems. We say that a family of machines solves with bounded-error probability if there exists a constant such that, for all , (i) for all , and (ii) for all , . Note that we do not require any condition on all strings outside of . We say that any input in is valid inputs. We also say that is promised if .

As noted in Section 1.1, we use the prefix “para-” to describe parameterized complexity classes. We define as the class of parameterized decision problems solvable by bounded-error QTMs using space, where is any log-space size parameter. If the expected runtime of each underlying QTM is further limited to a polynomial in , we write . The probabilistic counterparts of and are respectively denoted by and . With the use of deterministic and nondeterministic Turing machines instead, we similarly obtain and , respectively, as in [49]. Moreover, we write to denote the parameterization of , which is obtained by replacing languages with parameterized decision problems . Similarly, we obtain , , etc. See also [49].

2.5 Nonuniform State Complexity

Our purpose is to introduce nonuniform complexity classes defined by state complexities of quantum finite automata families. Related to these classes, we also consider classes based on probabilistic finite automata.

The state complexity generally refers to the number of inner states used in a given automaton. However, since we use a (uniform or nonuniform) family of finite automata, the state complexity of such a family becomes a function in . More formally, the state complexity (or ) of a family of finite automata is a function defined by for all indices , where denotes a set of inner states of [33]. In later sections, we use nonuniform families of finite automata and therefore we emphatically call the nonuniform state complexity function.

The nonuniform state complexity class is the collection of all nonuniform families over certain alphabets satisfying the following: there are a polynomial and a nonuniform family of 1dfa’s such that, for each index , (i) has at most states and (ii) solves on all inputs. In a similar way, we can define using 1nfa’s instead of 1dafa’s. Moreover, the notation indicates the collection of families of promise decision problems, each of which is recognized by a certain 1dfa of at most inner states for a certain polynomial . If we use families of 2dfa’s having polynomially many inner states, we obtain . In a similar fashion, with the use of nondeterministic finite automata, we can define , , and as well.

We present a useful lemma, which directly follows from Lemma 3.3 in [49, arXiv version]. This lemma will be used in later sections.

Lemma 2.3

[49] Let be a log-space size parameter over an alphabet . If is polynomially bounded and polynomially honest, there is a nonuniform family of 1dfa’s equipped with write-only output tapes such that each has states and produces on the output tape from each input .

We also consider finite automata whose input-tape heads either move to the right or stay still (or makes -moves). Such automata are briefly called 1.5 way. If we replace 1dfa’s in the definition of by 1.5dfa’s, then we obtain . Clearly, follows. Moreover, it turns out that coincides with . Nevertheless, as we will show in Lemma 3.7, this does not hold for quantum finite automata.

Lemma 2.4



Clearly, . For the converse, let be 1.5dfa’s. We want to simulate by a certain 1dfa of states. The desired 1dfa works as follows. On input , if moves its tape head to the right, then we make the same move. Assume that is in state and makes its tape head stay still. Assume that there are a number and a series of inner states for which , for any , and . Since must halt on , it follows that . We define a transition function of as . The obtained is clearly 1-way and simulates on all inputs. Note that uses at most states. ∎

3 One-Way Quantum Finite Automata Families

One-way finite automata are often used to model the circumstances where streamlined input data are processed instantly with little memory, since tape heads read input strings from the left to the right without stopping. Notice that, by our definition of one-wayness, 1-way automata halt exactly in steps for any input . In many cases, we can give clear separations among nonuniform state complexity classes.

Formally, the notation denotes the collection of nonuniform families of promise decision problems over fixed input alphabets (not depending on ) such that there exist a family of 1qfa’s, two polynomials and , and a constant satisfying the following: for each , (1) for any , if , then accepts with probability at least ; if , then rejects with probability at least , (2) uses at most inner states, and (3) ’s garbage alphabet has size at most . When satisfies Condition (1), we simply say that solves (or recognizes with error probability at most . In this case, is also said to make bounded errors. We obtain if we change Condition (1) to the following new condition: (1) given any index , for each , accepts with probability and, for any , rejects with probability . Occasionally, we say that makes unbounded errors. In addition, we obtain if, instead of Condition (1), we use the following condition: (1”) for any and any , if , then accepts with positive probability, and if , then rejects with certainty.

Since quantum computation depends on the choice of transition amplitudes, we occasionally emphasize a set, say, of such transition amplitudes and express its corresponding nonuniform state complexity classes as, for example, and .

We define in a similar way of defining but using one-way probabilistic finite automata (or 1pfa’s, for short), whose transition probabilities are arbitrary real numbers in , with unbounded-error probability. By using the bounded-error criteria, we can define (where “B” stands for “bounded error”). Similarly to , we can define , , , , etc.

There are known inclusions and separations: , , and [17, 18]. To obtain Figure 1, we further need the following additional collapse and separation relationships among nonuniform state complexity classes.

Theorem 3.1
  1. .

  2. and .

  3. .

  4. and .

  5. , , and .

  6. and