Unary languages recognized by two-way one-counter automata

Unary languages recognized by two-way one-counter automata

Marzio De Biasi 1 1marziodebiasi@gmail.com    Abuzer Yakaryılmaz Yakaryılmaz was partially supported by CAPES, ERC Advanced Grant MQC, and FP7 FET project QALGO.2University of Latvia, Faculty of Computing, Raina bulv. 19, Rīga, LV-1586, Latvia 23National Laboratory for Scientific Computing, Petrópolis, RJ, 25651-075, Brazil

A two-way deterministic finite state automaton with one counter (2D1CA) is a fundamental computational model that has been examined in many different aspects since sixties, but we know little about its power in the case of unary languages. Up to our knowledge, the only known unary nonregular languages recognized by 2D1CAs are those formed by strings having exponential length, where the exponents form some trivial unary regular language. In this paper, we present some non-trivial subsets of these languages. By using the input head as a second counter, we present simulations of two-way deterministic finite automata with linearly bounded counters and linear–space Turing machines. We also show how a fixed-size quantum register can help to simplify some of these languages. Finally, we compare unary 2D1CAs with two–counter machines and provide some insights about the limits of their computational power.

1 Introduction

A finite automaton with one-counter is a fundamental model in automata theory. It has been examined in many different aspects since sixties [8]. One recent significant result, for example, is that the equivalence problem of deterministic one-way counter automata is NL-complete [2]. After introducing quantum automata [21, 15] at the end of the nineties, quantum counter automata have also been examined (see a very recent research work in [28]).

A counter is a very simple working memory which can store an arbitrary long integer that can be incremented or decremented; but only a single bit of information can be retrieved from it: whether its value is zero or not. It is a well-known fact that a two-way deterministic finite automaton with two counters is universal [18, 19, 22]. Any language recognized by a two-way deterministic finite automaton with one counter (2D1CA), on the other hand, is in deterministic logarithmic space () [24].111Since a 2D1CA using super-linear space on its counter should finally enter an infinite loop, any useful algorithm can use at most linear space on a counter, which can be simulated by a logarithmic binary working tape. Replacing the counter of a 2D1CA with a stack, we get a two-way deterministic pushdown automaton (2DPDA), that can recognize more languages [7]. Similarly, nondeterminism also increases the class of the languages recognized by 2D1CAs [4].

Unary or tally languages, defined over a single letter alphabet, have deserved special attention. When the input head is not allowed to move to the left (one-way head), it is a well-known fact that unary nondeterministic pushdown automata can recognize only regular languages [9]. The same result was shown for bounded-error probabilistic pushdown automata, too [13]. Currently, we do not know whether “quantumness” can add any power. Their alternating versions were shown to be quite powerful: they can recognize any unary language in deterministic exponential time with linear exponent [3]. But, if we replace the stack with a counter, only a single family of unary nonregular languages [6] is known: for a given integer . In the case of two-way head, we know that the unary encoding of every language in deterministic polynomial time () can be accepted by 2DPDAs [20]; however we do not know whether 2DPDAs are more powerful than 2D1CAs (see also [11]) on unary languages like in the case of binary languages. Any separation between and can of course answer this question positively, but, it is still one of the big open problems in complexity theory. On the other hand, researchers also proposed some simple candidate languages not seemingly accepted by any 2D1CA [11, 23], e.g. Although it was shown that two–counter machines (2CAs) cannot recognize if the input counter is initialized with (i.e. no Gödelization is allowed) [12, 26], up to our knowledge, there is not any known nondeterministic, alternating, or probabilistic one-counter automaton for it. We only know that can be recognized by exponential expected time 2D1CAs augmented with a fixed-size quantum register [28] or realtime private alternating one-counter automata [5]. Apart from this open problem, we do not know much about which nonregular unary languages can be recognized by 2D1CAs. In this paper, we provide some answers to this question. In his seminal paper [18], Minsky showed that the emptiness problem for 2D1CAs on unary languages is undecidable. In his proof, he presented a simulation of two-way deterministic finite automaton with two counters on the empty string by a 2D1CA using its input head as a second counter. We use a similar idea but as a new programming technique for 2D1CAs on unary languages that allows to simulate multi-counter automata and space bounded Turing machines operating on unary or general alphabets. A 2D1CA can take the input and the working memory of the simulated machine as the exponent of some integers encoded on unary inputs. Thus, once the automaton becomes sure about the correctness of the encoding, it can start a two-counter simulation of the given machine, in which the second counter is implemented by the head on the unary input. Based on this idea, we will present several new nonregular unary languages recognized by 2D1CAs. Our technique can be applicable to nondeterministic, alternating, and probabilistic cases in a straightforward way. We also show that using a constant-size quantum memory can help to replace the encoding on binary alphabets with unary alphabets. Finally we compare unary 2D1CAs with 2CAs and provide some insights about the limits of their computational power.

2 Background

Throughout the paper, denotes the input alphabet and the extra symbols ¢ and are the end-markers (the tape alphabet is ). For a given string , is the reverse of , is the length of , and is the symbol of , where . The string is represented by . Each counter model defined in the paper has a two-way finite read-only input tape whose squares are indexed by integers. Any given input string, say , is placed on the tape as between the squares indexed by 0 and . The tape has a single head, and it can stay in the same position () or move to one square to the left () or to the right () in one step. It must always be guaranteed that the input head never leaves . A counter can store an integer and has two observable states: zero () or nonzero (), and can be updated by a value from in one step. Let .

A two-way deterministic one-counter automaton (2D1CA) is a two-way deterministic finite automaton with a counter. Formally, a 2D1CA is a 6-tuple

where is the set of states, is the initial state, () are the accepting and rejecting states, respectively, and is the transition function governing the behaviour of in each step, i.e.

Specifically, means that when is in state , reads symbol , and the state of its counter is , then it updates its state to and the position of the input head with respect to , and adds to the value of the counter. In order to stay on the boundaries of , if then and if then .

At the beginning of the computation, is in state , the input head is placed on symbol ¢, and the value of the counter is set to zero. A configuration of on a given input string is represented by a triple , where is the state, is the position of the input head, and is the value of the counter. The computation ends and the input is accepted (resp. rejected) by when it enters (resp. ).

For any , a two-way deterministic -counter automaton (2DCA) is a generalization of a 2D1CA and is equipped with counters; in each transition, it checks the states of all counters and then updates their values. Moreover, we call a counter linearly bounded if its value never exceeds , where is the given input. But restricting this bound to does not change the computational power of any kind of automaton having linearly bounded counters, i.e. the value of any counter can be compressed by any rational number by using extra control states. A two-counter automaton (2CA) is a 2D2CA over a unary alphabet and without the input tape: the length of the unary input is placed in one of the counters at the beginning of the computation. We underline that the length of the unary input is placed in the counter as it is: indeed if we allow a suitable encoding of the input (by Gödelization, e.g. setting its initial value to ) a 2CA can simulate any Turing machine [18, 26].

We replace “D” that stands for deterministic in the abbreviations of deterministic machines with “N”, “A”, and “P” for representing the abbreviations of their nondeterministic, alternating, and probabilistic counterparts.

We finish the section with some useful technical lemmas.

Lemma 1

2D1CAs can check whether a given string is a member of language , with .

Lemma 2

For any given , there exists a 2D1CA that can set the value of its counter to if its initial value is provided that the length of the input is at least , where , , and .

Lemma 3

The language can be recognized by a 2D1CA.

Lemma 4

For any given , a 2D2CA with values and in its counters can test whether divides without moving the input head and, after testing, it can recover the values of the counters.

3 Main results

We start with the simulation of linearly bounded multi–counter automata on unary languages and establish a direct connection with logarithmic-space unary languages. Secondly, we present the simulation of linear–space Turing machines on binary languages. Then we generalize this simulation for Turing machines that use more space and for Turing machines without any resource bound. Thirdly, we present our quantum result. We finish the section comparing unary 2D1CAs and 2CAs.

3.1 Simulation of multi-counter automata on unary alphabet

We assume that all linearly bounded counters do not exceed the length of the input. Let be a unary language recognized by a 2D2CA with linearly bounded counters and be the given input that is placed on the input tape (between the two end-markers as and indexed from 0 to ). We can represent the configurations of on with a state, an integer, and a Boolean variable as follows:



  • is the current state,

  • means that the input head is on ,

  • means that the input head is on the square, and,

  • (resp. ) represents the value of the first (resp. second) counter.

By using variable, we do not need to set to and this will simplify the languages that we will define soon. Note that we are using two exponents, i.e. , to store the position of the input head. In this way, we can implicitly store the length of the given input ().

Lemma 5

A 2D2CA, say , can simulate on without using its input head, if its first counter is set to .


For any , , by help of the second counter, can easily increase the exponent of by 1, test whether the exponent of is zero or not, and decrease the exponent of by 1 if it is not zero. Moreover, can keep the value of , which is at the beginning, by using its control states. Note that when the exponent of is zero and the input head of is moved to the right, the value of is set to ; and, whenever the input head of leaves the right end-marker, the value of is set to again. During both operations, the exponents of and remain the same. Thus, can simulate on and it never needs to use its input head. ∎

Note that, during the simulation given above, is always less than for any , and so, the values of both counters never exceed .

Now, we build a 2D1CA, say , simulating the computation of on some specific unary inputs. Let be the given input.

  1. checks whether the input is of the form for a non-negative integer (Lemma 1). If not, it rejects the input.

  2. sets its counter to (Lemma 2). Then, by using its input head as the second counter, it simulates which actually simulates on (Lemma 5). accepts (resp. rejects) the input if ends with the decision of “acceptance” (resp. “rejection”).

Thus, we can obtain that if can be recognized by a 2D2CA with linearly bounded counters, then is recognized by a 2D1CA. Actually, we can replace with by changing the representation given in Equation 1 as:

where is always less than for any .

Theorem 3.1

If can be recognized by a 2D2CA with linearly bounded counters, then is recognized by a 2D1CA.

Based on this theorem, we can easily show some languages recognized by 2D1CAs, e.g.

We can generalize our result for 2DCAs with linearly bounded counters in a straightforward way.

Theorem 3.2

Let and be some different prime numbers such that one of them is greater than the prime number. If can be recognized by a 2DCA with linearly bounded counters, then

is recognized by a 2D1CA.


Let . Since one prime number in , say , is greater than the prime number, there should be a prime number not in , say , that is not greater than the prime number. We can use the representation given in Equation 1 for a configuration of the 2DCA:

is always less than , and so, the integer part of the configuration is always less than . As described before, a 2D1CA can check whether the length of the input is a power of , and, if so, it can simulate the computation of the 2DCA on the input. The 2D1CA needs to simulate counters instead of 2 counters but the technique is essentially the same. ∎

The simulation given above can be easily generalized for nondeterministic, alternation, and probabilistic models. The input check and the initialization of the simulation are done deterministically. Therefore, the computation trees of the simulated and simulating machines have the same structure for the well-formed inputs, i.e. the inputs not rejected by the initial input check.

Theorem 3.3

Let and be some different prime numbers such that one of them is greater than the prime number. If can be recognized by a 2NCA (resp. 2ACA, bounded-error 2PCA, or unbounded-error 2PCA) with linearly bounded counters, then

is recognized by a 2N1CA (resp. 2A1CA, bounded-error 2P1CA, or unbounded-error 2P1CA).

Now, we establish the connection with logarithmic-space unary languages. The following two easy lemmas are a direct consequence of the fact that, over unary alphabet, a linear bounded counter can be simulated by the head position and vice versa.

Lemma 6

Any two-way automaton with -heads on unary inputs can be simulated by a two-way automaton with -linearly bounded counters, where .

The reverse simulation holds even on generic alphabets.

Lemma 7

Any two-way automaton with -linearly bounded counters can be simulated by a two-way automaton with -heads, where .

Both simulations work for deterministic, nondeterministic, alternating, and bounded- and unbounded-error probabilistic models.

Fact 1

[10, 14, 16] The class of languages recognized by two-way multi-head deterministic, nondeterministic, alternating, bounded-error probabilistic, and unbounded-error probabilistic finite automata are

(deterministic, nondeterministic, alternating, bounded-error probabilistic, and unbounded-error probabilistic logarithmic space) respectively.

Based on this fact, the last two lemmas, and the other results in this section, we can obtain the following theorem.

Theorem 3.4

Let be any unary language in (resp., , , , and ). Then there is an integer , product of some primes, such that

can be recognized by a 2D1CA (resp., 2N1CA, 2A1CA, bounded-error 2P1CA, and unbounded-error 2P1CA).

3.2 Simulation of Turing machines on binary and general alphabets

Let be a single-tape single-head DTM (deterministic Turing machine) working on a binary alphabet . Note that its tape alphabet also contains the blank symbol . We assume that the input is written between two blank symbols for DTMs. We define some restrictions on :

  • There can be at most one block of non-blank symbols.

  • The tape head is placed on the right end-marker at the beginning of the computation which makes easier to explain our encoding used by the 2D3CA given below. Note that this does not change the computational power of the DTMs.

A configuration of on a given input, say , can be represented as where represents the current tape content and is the current state. Moreover, the tape head is on the last symbol of . The initial configuration is , where is the initial state. Here is the empty string. Note that can never be the empty string.

By replacing with 0, and and with 1s, we obtain a binary number representation of and – we will denote these binary numbers by and , respectively. Now, we give a simulation of by a 2D3CA, say , on .222We refer the reader to [17] for a general theory of simulations. does not have a tape but can simulate it by using three counters. During the simulation, keeps and on its two counters. If knows the state and the symbol under head, it can update the simulating tape. can keep the state of by its internal states and can easily check whether:

  • equals to 1 or is bigger than 1;

  • equals to 0, equals to 1, or bigger than 1;

  • the last digit of is zero or one; and

  • the last digit of is zero or one.

Based on these checks, can simulate the corresponding change on the tape (in a single step of ) with the values of the counters.

By a suitable encoding, two counters can simulate counters. Let be co-prime numbers. The values of all counters, say , can be represented as . A counter can hold this value, and, by using the second counter, can check if is equal to zero (Lemma 4) and it can simulate an appropriate increment/decrement operation on , where . Therefore, we can conclude that a 2D2CA, say , can simulate on by using prime numbers for encoding, if its first counter is set to . Here can use the exponents of and for keeping the content of the tape and the exponent of to simulate the third counter.

Let’s assume that uses exactly space, i.e. the tape head never leaves the tape squares initially containing . That is, the binary value of the tape is always less than twice of , which is , during the whole computation. Then the values of the counters can never exceed or , where the exponents are the numbers in binary. Note that the whole tape is kept by the exponent of and , and so, their product is always less than .

Theorem 3.5

If can be recognized by a DTM, say , in space with binary work alphabet, then

can be recognized by a 2D1CA, say .


rejects the input if it is not of the form (Lemma 1), where . Then, it sets its first counter to (Lemma 2). rejects the input, if is not of the form for some . We know that a 2D2CA can easily do this check if one of its counter is set to , i.e. it needs to check is odd and . So, can implement this test by using its input head as the second counter.

As described above, if its first counter is set to , the 2D2CA can simulate on a given input . Due to the space restriction on , we also know that the counter values (of the 2D2CA’s) never exceed . So, needs only to set its counter value to . firstly sets its counter to , and then transfers to the exponent of . ∎

Remark that the language recognized by can also be represented as

This representation is more convenient when considering DTMs working on bigger alphabets.

Corollary 1

Let and be a language recognized by a DTM in space with a work alphabet having elements. Then

can be recognized by a 2D1CA, where and is a number in base-.


The proof is almost the same by changing base- with base-. Additionally, the 2D1CA needs to check whether each digit of is less than . ∎

We know that 2D1CAs can recognize [23]. Therefore, by using a binary encoding, we can give a simulation of exponential space DTMs where the exponent is linear. Here, the input is supposed to be encoded into the exponent of the first block of ’s and the working memory in the second block of ’s.

Theorem 3.6

Let and be a language recognized by a DTM in space with a work alphabet having elements. Then

can be recognized by a 2D1CA, where and is a number in base-.

We can generalize this result for any arbitrary space-bounded DTMs. It is not hard to show that, for any , 2D1CAs can recognize

Corollary 2

Let and and be a language recognized by a DTM in space with a work alphabet with elements. Then

can be recognized by a 2D1CA, where and is a number in base-.

Note that, similar to the previous section, all of the above results are valid if we replace deterministic machines with nondeterministic, alternating, or probabilistic ones.

Now, we present a more general result.

Theorem 3.7

Let be a recursive enumerable language and be a DTM recognizing it (note that may not halt on some non-members). The language

where is a sufficiently big number that depends on , can be recognized by a two way deterministic one counter automaton .


We use a slight variation of the 2DCA simulation of a DTM given above. Informally the part of the input gives enough space to complete its simulation, i.e. decide the membership of using its head position as a second counter, being sure that its value never exceeds the size of the input.

First we show that if is large enough then a 2D1CA can recognize the language :

checks that the input is in the correct format (Lemma 3), then it simulates on like showed in the proof of Theorem 3.5. During its computation, if reaches the right end-marker, then it stops and rejects.

Suppose that on input the Turing machine does not halt: it visits an infinite number of empty cells of its tape or it enters an infinite loop. In both cases, the value of is irrelevant, and will never accept the input : in the first case for all values of will hit the right end-marker and will reject; in the second case, if is too low and has not enough space to simulate in the loop area of the tape it will hit the right end-marker and reject, if is large enough, will also enter the endless loop.

Now suppose that the Turing machine accepts (resp. rejects) then there are two possibilities: a) during its computation the 2D1CA (that uses the head position like a second counter) never reaches the right end-marker; in this case it can correctly accept (resp. reject) the input; or b) during its computation the 2D1CA reaches the right end-marker (informally it has not enough space) and cannot correctly decide the membership of ; but in this case we are sure that there exists a larger value that assures enough space to end the computation. Also for every , will correctly accept each string in

We can slightly modify and narrow the language it recognizes to exactly , i.e. making it accept each string in:

but reject each string in:

We can divide the natural numbers as follows:

Let be the maximum value of the second counter of during the simulation of the DTM on (for each member of , such value exists). must be in one of the above intervals, let’s say in . It is obvious that must be in the next interval .

The second counter can use the set instead of for update operations, i.e. the head moves three steps left or right instead of a single step, and using the internal states we can allow it to exceed the input length up to three times its value: when the head reaches the right end-marker it can keep track that it has made one “fold” and continues moving towards the left; thereafter, if it reaches the left end-marker, it records that it has made two folds and continues move rightward, and so on. When, after a fold, it hits the last end-marker again it can decrease the number of folds and continue. Let store the number of folds. When becomes 3, then the 2D1CA rejects the input immediately, i.e. the counter value reaches the value of three times of the input length.

On input , the second counter, that changes its value by , will exceed but will never try to exceed (). So, must be 1 at least once and never becomes 3. Therefore, the 2D1CA accepts the input if the simulation ends with the decision of “acceptance” and takes a non-zero value at least once but never takes the value of 3.

If the input is , for some positive integer , then the second counter must need to exceed , so, the value takes 3 before simulation terminates and the 2D1CA rejects the input.

If the input is , for some positive integer , then the second counter can be at most , so the value never takes the value of 1 during the simulation and the 2D1CA rejects the input. Thus, we can be sure that such has a minimum value and it corresponds to in the language . ∎

Note that if the language recognized by is recursive, then the same 2D1CA described in Theorem 3.7 is a decider for .

3.3 A quantum simplification

Ambainis and Watrous [1] showed that augmenting a two-way deterministic finite automata (2DFAs) with a fixed-size quantum register333It is a constant-size quantum memory whose dimension does not depend on the input length. The machine can apply to the register some quantum operators (unitary operators, measurements, or superoperators) determined by the classical configuration of the machine. If the operator is a measurement or a superoperator, then there can be more than one outcome and the next classical transition is also determined by this outcome, which makes the computation probabilistic. However, as opposed to using a random number generator, the machine can store some information on the quantum register and some pre-defined branches can disappear during the computation due to the interference of the quantum states, which can give some extra computational power to the machine. makes them more powerful than 2DFAs augmented with a random number generator. Based on a new programming technique given for fixed-size quantum registers [29], it was shown that 2D1CAs having a fixed-size quantum register can recognize or any similar language by replacing bases 2 or 3 with some other integers for any error bound [27, 25]. Therefore, we can replace binary encoding with a unary one for Theorem 6 by enhancing a 2D1CA with a fixed-size quantum register.

Theorem 3.8

Let and be a language recognized by a DTM in space with a work alphabet having elements. Then

can be recognized by a 2D1CA augmented with a fixed-size quantum register for any error bound, where is a number in base- and .


Here the input check can be done by the help of the quantum register by using the corresponding quantum algorithms given in [27]. Then, our standard deterministic simulation is implemented. ∎

3.4 Unary 2D1CAs versus two-counter machines

Minsky [18] showed that, for any given recursive language defined over ,

can be recognized by a 2CA444The definition used by Minsky is a little different than ours but they are equivalent.. It is clear that is recursive enumerable if and only if is recursive enumerable. Moreover, any language not recognizable by any -space DTM, cannot be recognized by any -space DTM, for any . On the other hand, any language recognized by a 2D1CA is in (see Footnote 1). Therefore, there are many recursive and non-recursive languages recognized by 2CAs but not by 2D1CAs.

Neverthless we believe that 2CAs and unary 2D1CAs are incomparable, i.e. there also exist languages recognizable by a 2D1CA but not by any 2CA. Let , be the alphabet, and be a function mapping , -ary representation of , to

Both 2D1CAs and 2CAs can calculate symbol by symbol on the input , and the following is immediate:

Lemma 8

If is a regular languages over an alphabet of symbols, then a 2D1CA can decide the language .


Suppose that is a DFA that decides ; after transferring the input to the counter, a 2D1CA can calculate incrementally the digits up to the final fixed digit: it repeatedly divides the counter by , and is the remainder of the division; so it can simulate the transition of on symbol , and accept or reject accordingly when it reaches the last digit. ∎

Hence both 2D1CAs and 2CAs can recognize the whole class of unary languages:

As an example the family of unary non regular languages is contained in . But, we conjecture that the following language cannot be recognized by 2CAs:

i.e. the binary representation and the ternary representation of have both even or odd length. A 2D1CA can easily decide : after calculating if the length of the binary representation of is odd or even, it can recover the input using the tape endmarkers, and then check if the length of the ternary representation of is the same. But there is no way for a 2CA to recover the input, so it should calculate the binary and ternary representations of in parallel, which seems impossible.

Acknowledgements. We thank Alexander Okhotin, Holger Petersen, and Klaus Reinhardt for their answers to our questions on the subject matter of this paper. We also thank anonymous referees for their very helpful comments.


  • [1] Andris Ambainis and John Watrous. Two–way finite automata with quantum and classical states. Theoretical Computer Science, 287(1):299–311, 2002.
  • [2] Stanislav Böhm, Stefan Göller, and Petr Jancar. Equivalence of deterministic one-counter automata is NL-complete. In STOC, pages 131–140. ACM, 2013.
  • [3] Ashok K. Chandra, Dexter C. Kozen, and Larry J. Stockmeyer. Alternation. Journal of the ACM, 28(1):114–133, 1981.
  • [4] Marek Chrobak. Nondeterminism is essential for two-way counter machines. In Proceedings of the Mathematical Foundations of Computer Science 1984, volume 176 of LNCS, pages 240–244, 1984.
  • [5] H. Gökalp Demirci, Mika Hirvensalo, Klaus Reinhardt, A. C. Cem Say, and Abuzer Yakaryılmaz. Classical and quantum realtime alternating automata. In NCMA, volume 282 of books@ocg.at. Austrian Computer Society, 2014. (arXiv:1407.0334).
  • [6] Pavol Ďuriš. Private communication, October 2013.
  • [7] Pavol Ďuriš and Zvi Galil. Fooling a two way automaton or one pushdown store is better than one counter for two way machines. Theoretical Computer Science, 21:39–53, 1982.
  • [8] Patrick C. Fischer, Albert R. Meyer, and Arnold L. Rosenberg. Counter machines and counter languages. Mathematical Systems Theory, 2(3):265–283, 1968.
  • [9] Seymour Ginsburg and H. Gordon Rice. Two families of languages related to ALGOL. Journal of the ACM, 9(3):350–371, 1962.
  • [10] Juris Hartmanis. On non-determinancy in simple computing devices. Acta Informatica, 1:336–344, 1972.
  • [11] Oscar H. Ibarra, Tao Jiang, Nicholas Q. Trân, and Hui Wang. On the equivalence of two-way pushdown automata and counter machines over bounded languages. International Journal of Foundations of Computer Science, 4(2):135–146, 1993.
  • [12] Oscar H. Ibarra and Nicholas Q. Trân. A note on simple programs with two variables. Theoretical Computer Science, 112(2):391–397, 1993.
  • [13] Janis Kaneps, Dainis Geidmanis, and Rusins Freivalds. Tally languages accepted by Monte Carlo pushdown automata. In RANDOM, volume 1269 of LNCS, pages 187–195. Springer, 1997.
  • [14] K. N. King. Alternating multihead finite automata. Theoretical Computer Science, 61(2-3):149–174, 1988.
  • [15] Attila Kondacs and John Watrous. On the power of quantum finite state automata. In FOCS’97: Proceedings of the 38th Annual Symposium on Foundations of Computer Science, pages 66–75, 1997.
  • [16] Ioan I. Macarie. Multihead two-way probabilistic finite automata. Theory of Computing Systems, 30(1):91–109, 1997.
  • [17] Peter van Emde Boas. Handbook of Theoretical Computer Science (vol. A), chapter Machine models and simulations, pages 1–66. 1990.
  • [18] Marvin Minsky. Recursive unsolvability of Post’s problem of “tag” and other topics in theory of Turing machines. Annals of Mathematics, 74(3):437–455, 1961.
  • [19] Marvin Minsky. Computation: Finite and Infinite Machines. Prentice-Hall, 1967.
  • [20] Burkhard Monien. Deterministic two-way one-head pushdown automata are very powerful. Information Processing Letters, 18(5):239–242, 1984.
  • [21] Cristopher Moore and James P. Crutchfield. Quantum automata and quantum grammars. Theoretical Computer Science, 237(1-2):275–306, 2000.
  • [22] Kenichi Morita. Universality of a reversible two-counter machine. Theoretical Computer Science, 168(2):303–320, 1996.
  • [23] Holger Petersen. Two-way one-counter automata accepting bounded languages. SIGACT News, 25(3):102–105, 1994.
  • [24] Holger Petersen. Private communication, June 2012.
  • [25] Klaus Reinhardt and Abuzer Yakaryılmaz. The minimum amount of useful space: New results and new directions. In Developments in Language Theory, 2014 (to appear). arXiv:1405.2892.
  • [26] Rich Schroeppel. A two counter machine cannot calculate . Technical Report AIM-257, MIT, 1972.
  • [27] Abuzer Yakaryılmaz. Log-space counter is useful for unary languages by help of a constant-size quantum register. Technical Report arXiv:1309.4767, 2013.
  • [28] Abuzer Yakaryılmaz. One-counter verifiers for decidable languages. In CSR, volume 7913 of LNCS, pages 366–377. Springer, 2013.
  • [29] Abuzer Yakaryılmaz and A. C. Cem Say. Succinctness of two-way probabilistic and quantum finite automata. Discrete Mathematics and Theoretical Computer Science, 12(2):19–40, 2010.
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
Add comment
Loading ...
This is a comment super asjknd jkasnjk adsnkj
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test description