On Store Languages of Language Acceptors

TL;DR

This paper investigates the store languages of various automata models, showing their regularity, exploring their properties, and applying these findings to prove closure properties and space complexity bounds.

Contribution

It introduces a unified study of store languages across multiple automata models, identifies their regularity, and applies these results to prove closure properties and complexity bounds.

Findings

Store languages of all examined automata models are regular.

Connections between store languages of one-way and two-way machines are established.

A technique for proving closure under right quotient with regular languages is developed.

Abstract

It is well known that the "store language" of every pushdown automaton -- the set of store configurations (state and stack contents) that can appear as an intermediate step in accepting computations -- is a regular language. Here many models of language acceptors with various data structures are examined, along with a study of their store languages. For each model, an attempt is made to find the simplest model that accepts their store languages. Some connections between store languages of one-way and two-way machines generally are demonstrated, as with connections between nondeterministic and deterministic machines. A nice application of these store language results is also presented, showing a general technique for proving families accepted by many deterministic models are closed under right quotient with regular languages, resolving some open questions (and significantly simplifying proofs for others that are known) in the literature. Lower bounds on the space complexity for recognizing store languages for the languages to be non-regular are obtained.

Equations

$$(q^{\prime },{\iota }_1,\dots ,{\iota }_k)\in \delta (q,a,d_1,\dots ,d_k),$$

$$S(M)=\{q\gamma_{1}\cdots\gamma_{k}\mid\begin{array}[t]{l}(q_{0},uv,c_{0,1},\ldots,c_{0,k})\vdash_{M}^{x}(q,v,\gamma_{1},\ldots,\gamma_{k})\vdash_{M}^{y}(q_{f},\epsilon,\gamma_{1}^{\prime},\ldots,\gamma_{k}^{\prime}),\\ q_{f}\in F,u,v\in\Sigma^{*},\gamma_{i},\gamma_{i}^{\prime}\in\Gamma_{i},1\leq i\leq k,x,y\in T^{*},xy\mbox{~{}is valid}\}.\end{array}$$

$$\delta (q_0,c,d)=\{(q_0,dc)\},\forall d\in \{Z_0,a,b\},c\in \{a,b\},$$

$$\delta (q_1,c,c)=\{(q_1,ϵ)\},\forall c\in \{a,b\},$$

$$\delta (q_0,c,\text{leavevmode}\text{ignorespaces}\text{␣})=\{(q_1,c^{\to })\},\forall c\in \{a,b\},$$

$$\delta (q_1,\$,\text{leavevmode}\text{ignorespaces}\text{␣})=\{(q_2,\text{leavevmode}\text{ignorespaces}{\text{␣}}^{\leftarrow })\}$$

$$\delta (q_2,ϵ,\text{leavevmode}\text{ignorespaces}\text{␣})=\{(q_3,\text{leavevmode}\text{ignorespaces}{\text{␣}}^{\to })\},$$

$$\delta (q_3,⊲,\text{leavevmode}\text{ignorespaces}\text{␣})=\{(q_4,\text{leavevmode}\text{ignorespaces}\text{␣})\}.$$

$$S(M)=\begin{array}[t]{l}\{q_{4}x\leavevmode\hbox{\ignorespaces\verb*!␣! }\downarrow\ \mid x\in\{a,b\}^{+}\}\cup\{q_{3}x_{1}\downarrow x_{2}\mid\mbox{either~{}}x_{1}\in\{a,b\}^{+},x_{2}\in\{a,b\}^{*}\mbox{~{}or~{}}x_{1}\in\{a,b\}^{+}\leavevmode\hbox{\ignorespaces\verb*!␣! },x_{2}=\epsilon\}\cup\\ \{q_{2}x_{1}\downarrow x_{2}\mid\mbox{~{}either~{}}x_{1}\in\{a,b\}^{+},x_{2}\in\{a,b\}^{*}\mbox{~{}or~{}}x_{1}=\leavevmode\hbox{\ignorespaces\verb*!␣! },x_{2}\in\{a,b\}^{+}\}\cup\{q_{1}x_{1}\leavevmode\hbox{\ignorespaces\verb*!␣! }\downarrow\ \mid x_{1}\in\{a,b\}^{+}\}\\ \cup\{q_{0}\leavevmode\hbox{\ignorespaces\verb*!␣! }\downarrow\},\end{array}$$

$$\alpha :(r_0,w_0,{\gamma }_0)⊢\cdots ⊢(r_m,w_m,{\gamma }_m),$$

$$f(\alpha )=p_1,\dots ,p_{2l}\in X,$$

$$[(q,a,d_1,\dots ,d_k)\to (p,y_1,\dots ,y_k)],$$

$$⊳a^{i_1}{b}^{j_1}{a}^{i_2}{b}^{j_2}\cdots a^{i_k}{b}^{j_k}⊲$$

$$\{wx\mid wx\in L(M_1),x\in L(M_2)\}.$$

Full text

††journal: Theoretical Computer Science

\newclass\NQA

NQA \newclass\NSANSA \newclass\NFPANFPA \newclass\DCMDCM \newclass\eDCMeDCM \newclass\eNPDAeNPDA \newclass\DPDADPDA \newclass\PDAPDA \newclass\DCMNEDCM_NE \newclass\TwoDCM2DCM \newclass\NCMNCM \newclass\eNCMeNCM \newclass\eNQAeNQA \newclass\eNSAeNSA \newclass\eNPCMeNPCM \newclass\eNQCMeNQCM \newclass\eNSCMeNSCM \newclass\DPCMDPCM \newclass\NPCMNPCM \newclass\NQCMNQCM \newclass\DQCMDQCM \newclass\NSCMNSCM \newclass\NPDANPDA \newclass\TRETRE \newclass\NFANFA \newclass\DFADFA \newclass\NCANCA \newclass\DCADCA \newclass\DTMDTM \newclass\NTMNTM \newclass\DLOGDLOG

label1]ibarra@cs.ucsb.edu

label2]mcquillan@cs.usask.ca

1 Introduction

A store configuration of a one-way or two-way language acceptor consists of the state followed by the contents of its memory (store) structure. It does not include the input and the position of the input head. For example, for a nondeterministic pushdown automaton ($\NPDA$), a store configuration is represented by a string $qx$, where $q$ is a state and $x$ is the contents of the pushdown stack. For multi-tape acceptors, such as for an $\NPDA$ augmented with $k$ reversal-bounded counters ($\NPCM$) [1], the store configuration is represented by the string $qxc_{1}^{j_{1}}\cdots c_{k}^{j_{k}}$, where $j_{i}$ represents the value of counter $i$ in unary notation, and the $c_{i}$ symbols and the symbols of $x$ are disjoint. For a machine $M$, let $S(M)$ be the set of store configurations that can appear as an intermediate step in accepting computations of $M$.

It is well-known that $S(M)$ is a regular language for any $\NPDA$ $M$ [2, 3]. Greibach used this result to provide an alternative proof [3] that regular canonical systems produce regular languages [4]. Also, it was a key component to showing that it is decidable whether the set of all infixes (subwords) of the language accepted by a reversal-bounded444Reversal-bounded means that there is a bound on the number of switches between non-decreasing and non-increasing the size of the pushdown. $\NPDA$ is equal to $\Sigma^{*}$ (i.e., is dense) [5]. Connections between store languages and the area of verification and model checking have also been recently explored [6].

Due to the usefulness of the store language concept, the store languages of several models of language acceptors are studied in this paper. For machine models with an undecidable emptiness problem, membership in the store language is undecidable. Hence, the investigation of store languages is particularly focused on machine models with a decidable emptiness problem. Results are given here that generalize (in often non-obvious ways) the aforementioned result concerning $\NPDA$s to many other machine models, such as the following:

The following nondeterministic machine models with one-way read-only input have regular store languages: $k$-flip pushdown automata [7] (which are like pushdown automata but can flip the pushdown store up to $k$ times), reversal-bounded queue automata, nondeterministic Turing machines with a reversal-bounded worktape, and stack automata [8, 9]. The result for stack automata was shown recently [10] and so our result becomes an alternate proof that follows from existing results in the literature. Also, a new simple but general method is presented for translating results between two-way machines and one-way machines. 2. 2.

The store languages of finite-crossing555Finite-crossing means that the input head crosses the boundary of any two adjacent input symbols at most a fixed number of times. two-way nondeterministic machines with reversal-bounded counters can be accepted by one-way deterministic machines with reversal-bounded counters ($\DCM$). 3. 3.

There is a non-finite-crossing two-way deterministic machine with one reversal-bounded counter whose store language cannot be accepted by any $\NPCM$. 4. 4.

Some machine models (e.g., deterministic pushdown automata with reversal-bounded counters, $\DPCM$) cannot accept their own store languages.

$\NPCM$s and $\NCM$s have been extensively studied since their introductions in [1, 11]. They have found applications in areas such as timed automata [12], model-checking and verification [13, 14], membrane computing [15], and Diophantine equations [16].

Another interesting application is presented here showing the closure of many families of languages accepted by deterministic machines under right quotient with regular languages. Some of these resolve open problems in the literature, and others simplify existing known proofs. These include deterministic stack automata (known with a lengthy proof in [17]), deterministic $k$-flip pushdown automata (stated as an unresolved open problem in [18]), certain types of deterministic Turing machines, deterministic checking stack automata, and deterministic reversal-bounded queue automata. An alternate proof of the result for deterministic pushdown automata that was shown in [19] is also given. This general closure is somewhat surprising given the determinism of the machines and the nondeterministic nature of deletion occurring with quotients.

Finally, lower bounds are obtained on the space complexity of different types of Turing machines in order to have non-regular store languages.

2 Notation

An alphabet $\Sigma$ is a set of symbols (usually assumed to be finite unless stated otherwise). The set of all words over $\Sigma$ is denoted by $\Sigma^{*}$, and the set of all non-empty words is denoted by $\Sigma^{+}$. A language $L$ over $\Sigma$ is any subset of $\Sigma^{*}$. Given a word $w\in\Sigma^{*}$, the length of $w$ is denoted by $|w|$. Given $a\in\Sigma$, then $|w|_{a}$ is the number of $a$’s in $w$. The empty word is denoted by $\epsilon$. The reverse of a word $w$ is denoted by $w^{R}$, extended to the reverse $L^{R}$ of a language $L$ in the natural way. Given two languages $L_{1},L_{2}$, the left quotient of $L_{2}$ by $L_{1}$, $L_{1}^{-1}L_{2}=\{y\mid xy\in L_{2},x\in L_{1}\}$, and the right quotient of $L_{1}$ by $L_{2}$ is $L_{1}L_{2}^{-1}=\{x\mid xy\in L_{1},y\in L_{2}\}$. A language $L\subseteq\Sigma^{*}$ is letter-bounded if there exists (not necessarily distinct) $a_{1},\ldots,a_{l}\in\Sigma$ such that $L\subseteq a_{1}^{*}\cdots a_{l}^{*}$. A language $L$ is bounded if there exists $w_{1},\ldots,w_{l}\in\Sigma^{*}$ such that $L\subseteq w_{1}^{*}\cdots w_{l}^{*}$. Given two words $u,v\in\Sigma^{*}$, $u$ is a prefix of $v$ if $v=ux$, for some $x\in\Sigma^{*}$, $u$ is a suffix of $v$ if $v=xu$ for some $x\in\Sigma^{*}$, $u$ is an infix of $v$ if $v=xuy$, for some $x,y\in\Sigma^{*}$, and $u$ is a subsequence of $v$ if $v=x_{0}u_{1}x_{1}\dots x_{n-1}u_{n}x_{n},x_{0},\ldots,x_{n},u_{1},\ldots,u_{n}\in\Sigma^{*},u=u_{1}\cdots u_{n}$.

In this paper, introductory knowledge of automata and formal language theory is assumed (see [20] for an introduction), including finite automata ($\NFA$s and $\DFA$s), pushdown automata ($\NPDA$s), Turing machines ($\NTM$s and $\DTM$s), and generalized sequential machines (gsms). Let ${\cal L}(\REG)$ be the family of languages accepted by $\NFA$s.

3 Store Languages of One-Way Machines

Many different kinds of machine models are studied in this paper, such as finite automata, pushdown automata [20], reversal-bounded multicounter machines [1], stack automata (similar to a pushdown automata with the ability to read, but not change on the inside of the pushdown) [8, 9], Turing machines [20], queue automata [21], flip-pushdown automata (machines with the ability to flip the pushdown at most $k$ times) [7], and also combinations of their stores within individual machines. The store language of each depends on the precise definition of each type of machine. It is possible to define all such models generally by varying the “store type” similar to Abstract Families of Automata [22] or storage types [23], and then the store language only needs to be defined once for all types of machines. A similar approach is followed here due to the large number of machine models considered, because it allows to make general connections between types of machines, and because store languages depend considerably on the precise definition of the machines.

Definition 1

A store type is a tuple $\Omega=(\Gamma,I,f,g,c_{0},L_{I})$, where

• •

$\Gamma$* is the set of store symbols (potentially infinite, available to all machines using this store),*

• •

$I$* is the set of instructions,*

• •

$f$* is the write function, a partial function from $\Gamma^{*}\times I$ to $\Gamma^{*}$,*

• •

$g$* is the read function, a partial function from $\Gamma^{*}$ to $\Gamma$,*

• •

$c_{0}\in\Gamma^{*}$* is the initial store configuration,*

• •

$L_{I}\subseteq I^{*}$* is the instruction language.*

Thus, a store type defines a type of auxiliary store. The write function $f$ indicates how each store contents change in response to each instruction, and the read function $g$ indicates how machines read from each store contents. Every machine using this store type starts with $c_{0}$ on its store. Lastly, $L_{I}$ is a type of filter that can restrict the allowable sequences of instructions. This is useful for several purposes, such as defining reversal-bounded store types.

Example 1

The pushdown store type is $\Omega=(\Gamma,I,f,g,c_{0},L_{I})$ where $c_{0}=Z_{0}\in\Gamma$, $\Gamma_{0}=\Gamma-\{Z_{0}\}$ ($Z_{0}$ is the bottom-of-stack marker), $I=\Gamma^{*}$, $L_{I}=I^{*}$ (i.e. there is no restriction as to the possible sequences of instructions), $g(xa)=a,x\in\Gamma^{*},a\in\Gamma$, $f(xa,y)=xy$, where $y\in\Gamma^{*},xa,xy\in Z_{0}\Gamma_{0}^{*}$.

Intuitively, a pushdown store can read the rightmost symbol, and can replace the rightmost symbol with any word; these words are the instructions (which can be the empty word for popping).

The machines (defined next) using this store type are equivalent to standard pushdown automata [20].

Definition 2

Given store types $\Omega_{1},\ldots,\Omega_{k}$ with $\Omega_{i}=(\Gamma_{i},I_{i},f_{i},g_{i},c_{0,i},L_{I,i}),1\leq i\leq k$, where $\Gamma_{i}$ are pairwise disjoint, for $1\leq i\leq k$, a one-way nondeterministic $(\Omega_{1},\ldots,\Omega_{k})$-machine is a tuple $M=(Q,\Sigma,\Gamma,\delta,q_{0},F)$, where $Q$ is the finite set of states, $\Sigma$ is the input alphabet, $q_{0}\in Q$ is the initial state, $F\subseteq Q$ is the set of final states, $\Gamma$ is a finite subset of $\Gamma_{1}\cup\cdots\cup\Gamma_{k}$, and the finite transition relation $\delta$ is from $Q\times(\Sigma\cup\{\epsilon\})\times\Gamma_{1}\times\cdots\times\Gamma_{k}$ to $Q\times I_{1}\times\cdots\times I_{k}$.

A configuration of $M$ is a tuple $(q,w,\gamma_{1},\ldots,\gamma_{k})$, where $q\in Q$ is the current state, $w\in\Sigma^{*}$ is the remaining input, and $\gamma_{i}\in\Gamma_{i}^{*}$ is the contents of the $i$’th store, for $1\leq i\leq k$. The derivation relation $\vdash_{M}$ is defined by: $(q,aw,\gamma_{1},\ldots,\gamma_{k})\vdash_{M}(q^{\prime},w,\gamma_{1}^{\prime},\ldots,\gamma_{k}^{\prime}),w\in\Sigma^{*},a\in\Sigma\cup\{\epsilon\},\gamma_{i},\gamma_{i}^{\prime}\in\Gamma_{i}^{*},1\leq i\leq k,q,q^{\prime}\in Q$, if there exists

[TABLE]

such that $g_{i}(\gamma_{i})=d_{i},f(\gamma_{i},\iota_{i})=\gamma_{i}^{\prime}$, for all $i$, $1\leq i\leq k$. This is extended to $\vdash_{M}^{*}$, the reflexive and transitive closure of $\vdash_{M}$. Sometimes, bijective labels $T$ will be associated with transitions of $M$, and in such cases, the derivation relation using transition $t$ is sometimes written as $\vdash_{M}^{t},t\in T$, generalized to words $\vdash_{M}^{x},x\in T^{*}$. For $1\leq i\leq k$, define a homomorphism $\pi_{i}$ from $T^{*}$ to $I_{i}^{*}$ where $\pi_{i}(t)=\iota_{i}$ for $t$ of the form of (1). Then $x\in T^{*}$ is valid if $\pi_{i}(x)\in L_{I,i},$ for each $i$, $1\leq i\leq k$.

The language accepted by $M$, $L(M)=\{w\mid(q_{0},w,c_{0,1},\ldots,c_{0,k})\vdash^{x}_{M}(q_{f},\epsilon,\gamma_{1},\ldots,\gamma_{k}),q_{f}\in F,w\in\Sigma^{*},\gamma_{i}\in\Gamma_{i},1\leq i\leq k,x\in T^{*}\mbox{~{}is valid}\}$.

The store language of $M$,

[TABLE]

Thus, $S(M)$ is the set of store configuration representatives that can appear as an intermediate step of an accepting computation. It is also enforced that, if $k>1$, then $\Gamma_{1},\ldots,\Gamma_{k}$ are all disjoint. By a slight abuse of notation, machines with several tapes that have the same store type are assumed to have disjoint tape alphabets. Thus, since the letters used in each component are disjoint, when reading a string of $S(M)$, it is possible to know which of the $k$ stores is being read.

Definition 3

For a given set of machines ${\cal M}$, let ${\cal L}({\cal M})$ be the family of languages accepted by machines in ${\cal M}$, and ${\cal S}({\cal M})$ be the family of store languages of machines in ${\cal M}$.

Various types of one-way deterministic automata will also be studied in this paper. These machines are defined to scan input $w\lhd$, where $w\in\Sigma^{*}$, and $\lhd$ is the right end-marker (this is needed for some types of machines such as $\DCM$ [24]). Then, a machine is deterministic if $|\delta(q,a,d_{1},\ldots,d_{k})\cup\delta(q,\epsilon,d_{1},\ldots,d_{k})|\leq 1$ for all $q\in Q,a\in\Sigma\cup\{\lhd\},d_{i}\in\Gamma_{i}$, the language accepted by $M$, $L(M)=\{w\mid(q_{0},w\lhd,c_{0,1},\ldots,c_{0,k})\vdash^{x}_{M}(q_{f},\epsilon,\gamma_{1},\ldots,\gamma_{k}),q_{f}\in F,w\in\Sigma^{*},\gamma_{i}\in\Gamma_{i}^{*},1\leq i\leq k,x\mbox{~{}is valid}\}$, and the store language of $M$, $S(M)=\{q\gamma_{1}\cdots\gamma_{k}\mid(q_{0},w\lhd,c_{0,1},\ldots,c_{0,k})\vdash^{x}_{M}(q,w^{\prime},\gamma_{1},\ldots,\gamma_{k})\vdash_{M}^{y}(q_{f},\epsilon,\gamma_{1}^{\prime},\ldots,\gamma_{k}^{\prime}),q_{f}\in F,w\in\Sigma^{*},w^{\prime}\in\Sigma^{*}\lhd\cup\{\epsilon\}\gamma_{i},\gamma_{i}^{\prime}\in\Gamma_{i}^{*},1\leq i\leq k,x,y\in T^{*},xy\mbox{~{}is valid}\}$.

Given store types $\Omega_{1},\ldots,\Omega_{k}$, the set of all one-way nondeterministic, or deterministic, $(\Omega_{1},\ldots,\Omega_{k})$-machines that can be built using this store type will be examined.

In this notation, store types that are equivalent to standard automata models from the literature will be described. Indeed, pushdown automata are machines that start with $Z_{0}$ on the pushdown, can read the top of the pushdown on its transitions, and replace the topmost letter with a word. These correspond with $\Omega$-machines as built with the pushdown store type of Example 1. Let $\NPDA$ be the set of all such pushdown automata.

An $l$-reversal-bounded pushdown store is the same except $L_{I}$ is set to the concatenation of $l$ alternating sequences of $(\{y\mid y\in\Gamma^{*},|y|\geq 1\})^{*}$ and $(\{y\mid y\in\Gamma^{*},|y|\leq 1\})^{*}$ i.e. there are at most $l$ alternations between non-decreasing and non-increasing the size of the stack.

A counter store type restricts a pushdown store to having a single symbol $c\in\Gamma_{0}$ (plus $Z_{0}$). At each step, essentially based on whether the counter is empty or non-empty, a machine can change each counter by $+1,0$, or $-1$. Similarly, $l$-reversal-bounded counters can be defined exactly like $l$-reversal-bounded pushdowns.

One can consider machines with $k$ $l$-reversal-bounded counters. The set of all machines that have $k$ $l$-reversal-bounded counters, for some $k,l\geq 1$ is denoted by $\NCM$. Note that $\NCM$ is a union of sets of machines that can be built using store types.

Example 2

A queue store type is a tuple $\Omega=(\Gamma,I,f,g,c_{0},L_{I})$, where $I=\{{\rm enqueue}(y)\mid y\in\Gamma^{*}\}\cup\{{\rm dequeue}\}$, $c_{0}=\epsilon$, $L_{I}=I^{*}$, $g(x)$ is $\epsilon$ if $x=\epsilon$, and the leftmost symbol of $x$ otherwise, $f(x,{\rm dequeue})=\Gamma^{-1}x$, and $f(x,{\rm enqueue}(y))=xy$.

Example 3

The $k$-flip-pushdown store type is a tuple $\Omega=(\Gamma,I,f,g,c_{0},L_{I})$, where $c_{0}=Z_{0}$, $\Gamma_{0}=\Gamma-\{Z_{0}\}$, $I=\Gamma^{*}\cup\{{\rm flip}\}$, $g(xa)=a,x\in\Gamma^{*},a\in\Gamma$, $f(xa,y)=xy$, where $y\in\Gamma^{*},xa,xy\in Z_{0}\Gamma_{0}^{*}$, and $f(x,{\rm flip})=Z_{0}(Z_{0}^{-1}x)^{R},x\in\Gamma^{*}$ (the pushdown above the end-marker flips), and $L_{I}$ restricts at most $k$ flip moves to be applied.

For example, consider a machine M=(Q,\Sigma,\Gamma,\delta,q_{0},F),\Sigma=\{a,b,\},F={q_{2}}$, with transitions

[TABLE]

In every accepting computation, $M$ must push all contents $w$ onto the stack until \$$, making a stack of Z_{0}w$, where a flip occurs producing$Z_{0}w^{R}$. Then the contents are popped and matched to the input. Thus,$L(M)={w$w\mid w\in{a,b}^{+}}$.

Machines defined with this type are equivalent to those in [7], although they are classically defined where the flips are performed with a separate function.

Next, we define stacks similarly to the definition in [8, 22]. They are defined like pushdowns, but there are also instructions to enter the inside of the stack in a two-way read-only fashion.

Example 4

The stack store type is a tuple $\Omega=(\Gamma,I,f,g,c_{0},L_{I})$, where $\Gamma$ is an infinite set of store symbols available to stacks, with special symbols $\downarrow\in\Gamma$ that gives the position of the read/write head in the stack, $Z_{b}\in\Gamma$ is the bottom-of-stack marker, and $Z_{t}\in\Gamma$ is the top-of-stack marker, with $\Gamma_{0}=\Gamma-\{\downarrow\}$, $\Gamma_{1}=\Gamma_{0}-\{Z_{b},Z_{t}\}$, $I=\Gamma_{0}^{*}\cup\{{\rm D},{\rm S},{\rm U}\}$ is the set of instructions of the stack, where the first set are changing the top symbol of the stack, and the rest (down, stay, or up) move the read/write head inside the stack, $L_{I}=I^{*}$, $c_{0}=Z_{b}\downarrow Z_{t}$, $g(xa\downarrow x^{\prime})=a,a\in\Gamma_{0},x,x^{\prime}\in\Gamma_{0}^{*}$ with $xax^{\prime}\in Z_{b}\Gamma_{1}^{*}Z_{t}$, and $f$ is defined as:

• •

$f(xa\downarrow Z_{t},y)=xy\downarrow Z_{t}$* for $x,y\in\Gamma_{0}^{*},a\in\Gamma_{0},xa,xy\in Z_{b}\Gamma_{1}^{*}$,*

• •

$f(Z_{b}xa\downarrow x^{\prime},{\rm D})=Z_{b}x\downarrow ax^{\prime}$, for $x,x^{\prime}\in\Gamma_{0}^{*},a\in\Gamma_{1}\cup\{Z_{t}\}$, with $xax^{\prime}\in\Gamma_{1}^{*}Z_{t}$,

• •

$f(Z_{b}x\downarrow x^{\prime},{\rm S})=Z_{b}x\downarrow x^{\prime}$, for $x,x^{\prime}\in\Gamma_{0}^{*},xx^{\prime}\in\Gamma_{1}^{*}Z_{t}$,

• •

$f(Z_{b}x\downarrow ax^{\prime},{\rm U})=Z_{b}xa\downarrow x^{\prime}$, for $x,x^{\prime}\in\Gamma_{0}^{*},a\in\Gamma_{1}\cup\{Z_{t}\},xax^{\prime}\in\Gamma_{1}^{*}Z_{t}$.

Also, the checking stack store type is a restriction of stack store type above where $L_{I}$ is restricted to be in $y\mid y\in\Gamma_{0}^{+}\}^{*}\{{\rm D},{\rm S},{\rm U}\}^{*}$. That is, a checking stack has two phases, a “writing phase”, where it can push or stay (no pop), and then a “reading phase”, where it enters the stack in read-only mode. But once it starts reading, it cannot change the stack again.

Stacks require that the read/write head be included in the store language in a similar fashion to Turing tapes, as defined next:

Example 5

*A Turing store is a tuple $\Omega=(\Gamma,I,f,g,c_{0},L_{I})$ where $c_{0}=\leavevmode\hbox{\ignorespaces\verb*!␣! }\downarrow$ ($\downarrow$ is the read/write head that reads the symbol before it, and ␣

is the blank symbol, so each tape initially only has a blank followed by the read/write head, $\Gamma_{0}=\Gamma-\{\downarrow\},\Gamma_{1}=\Gamma_{0}-\{\leavevmode\hbox{\ignorespaces\verb*!␣! }\}$), $I=\{a^{\leftarrow},a^{\rightarrow},a\mid a\in\Gamma_{0}\}$ (this groups together both the new symbol written in the current tape cell, and the direction for the head to move), $L_{I}=I^{*}$, $g(xb\downarrow x^{\prime})=b,b\in\Gamma_{0},x,x^{\prime}\in\Gamma_{0}^{*}$, $x$ does not start with ␣ , and $x^{\prime}$ does not end with ␣ . At each step, a machine with this store can read the symbol under the read/write head, and execute an instruction which corresponds to a standard Turing machine instruction, writing an $a$ in the current cell and moving left, right, or staying. The write function is defined by, for all $x\in\Gamma_{1}\Gamma_{0}^{*}\cup\{\epsilon\},x^{\prime}\in\Gamma_{0}^{*}\Gamma_{1}\cup\{\epsilon\},a,b\in\Gamma_{0}$:*

• •

$f(xb\downarrow x^{\prime},a)=xa\downarrow x^{\prime}$,

• •

$f(xb\downarrow x^{\prime},a^{\leftarrow})=\begin{cases}\leavevmode\hbox{\ignorespaces\verb*!␣! }\downarrow ax^{\prime}&\mbox{~{}if~{}}ax^{\prime}\notin\leavevmode\hbox{\ignorespaces\verb*!␣! }^{*}\mbox{~{}and~{}}x=\epsilon,\\ x\downarrow ax^{\prime}&\mbox{~{}if~{}}ax^{\prime}\notin\leavevmode\hbox{\ignorespaces\verb*!␣! }^{*}\mbox{~{}and~{}}x\neq\epsilon,\\ \leavevmode\hbox{\ignorespaces\verb*!␣! }\downarrow&\mbox{~{}if~{}}ax^{\prime}\in\leavevmode\hbox{\ignorespaces\verb*!␣! }^{*}\mbox{~{}and~{}}x=\epsilon,\\ x\downarrow&\mbox{~{}if~{}}ax^{\prime}\in\leavevmode\hbox{\ignorespaces\verb*!␣! }^{*}\mbox{~{}and~{}}x\neq\epsilon,\end{cases}$**

• •

$f(xb\downarrow x^{\prime},a^{\rightarrow})=\begin{cases}xac\downarrow x^{\prime\prime}&\mbox{~{}if~{}}xa\notin\leavevmode\hbox{\ignorespaces\verb*!␣! }^{*},x^{\prime}=cx^{\prime\prime},c\in\Gamma_{0},\\ c\downarrow x^{\prime\prime}&\mbox{~{}if~{}}xa\in\leavevmode\hbox{\ignorespaces\verb*!␣! }^{*},x^{\prime}=cx^{\prime\prime},c\in\Gamma_{0},\\ xa\leavevmode\hbox{\ignorespaces\verb*!␣! }\downarrow&\mbox{~{}if~{}}xa\notin\leavevmode\hbox{\ignorespaces\verb*!␣! }^{*},x^{\prime}=\epsilon,\\ \leavevmode\hbox{\ignorespaces\verb*!␣! }\downarrow&\mbox{~{}if~{}}xa\in\leavevmode\hbox{\ignorespaces\verb*!␣! }^{*},x^{\prime}=\epsilon.\end{cases}$**

A machine with one such store type is a Turing machine with a one-way read-only input tape, and one read/write store tape. The store starts off empty (a blank followed by the read/write head), and they can extend in both directions as symbols are added to the left and right. They can also shrink in size if everything to the right of the read/write head is a blank, as with the left. This is exactly how configurations of Turing machines change [20]. Furthermore, $l$-reversal-bounded 1-tape Turing stores can be defined by restricting $L_{I}$ so that the number of alternations between moving right and left on the tape is at most $l$.

For example, consider a deterministic machine $M=(Q,\Sigma,\Gamma,\delta,q_{0},F)$ with a $2$-reversal-bounded Turing store accepting \{w\w\mid w\in{a,b}^{+}}$, with$\Sigma={a,b},\Gamma={a,b,\leavevmode\hbox{\ignorespaces\verb!␣! },\downarrow},F={q_{4}}$, and$\delta$ is as follows:*

[TABLE]

Despite $L(M)$ being non-context-free, the store language

[TABLE]

which is a regular language.

Define machines with one pushdown for the first tape, and $k$ additional reversal-bounded counters, where each word in the store language is of the form $qxc_{1}^{j_{1}}\cdots c_{k}^{j_{k}}$, where $q$ is a state, $x$ is the contents of the pushdown, and $j_{1},\ldots,j_{k}$ are the contents of the counters. Let $\NPCM$ be the set of machines with one pushdown, and some number $k$ of counters where the pushdown is unrestricted, but the counters are reversal-bounded. The family of languages accepted by $\NPCM$ [1, 25] is of interest since it has a decidable emptiness and membership problem, and only accepts semilinear languages.

Let $\NQA$ be the set of queue automata [21]. As with $\NPCM$, define machines with one queue for the first tape, and $k$ additional counters. Let $\NQCM$ be the set of machines with one queue, and some number $k$ of counters where the counters are reversal-bounded (if the queue is also reversal-bounded, these only accept semilinear languages [21], otherwise they have the same power as Turing machines). Let $\NSA$ be the set of stack automata [9, 8]. Also, define machines with one stack for the first tape, and $k$ additional counters. Let $\NSCM$ be the set of machines with one stack, and some number $k$ of counters where the counters are reversal-bounded (if the stack is reversal-bounded, this implies that there is also a bound on the number of changes in direction of the read head when it reads inside the stack structure). Let $\NFPA$ be the set of $k$-flip pushdown machines, for some $k$ [7]. Replacing N with D gives each deterministic variant.

3.1 Store Languages of Turing Machines and Other One-Way Automata Models

Store languages have already been investigated for nondeterministic pushdown automata. It has been shown [2, 3] that the store language of each $\NPDA$ is a regular language. Moreover, the proof contains an effective construction.

Proposition 4

[2, 3]** Given a one-way $\NPDA$ $M$, $S(M)$ is a regular language, and ${\cal S}(\NPDA)\subseteq{\cal L}(\REG)$.

First, a general decidability proposition is proved for machine models where the emptiness problem is undecidable.

Proposition 5

Let ${\cal M}$ be a set of machines defined using (potentially multiple) store types, such that the emptiness problem is undecidable for $M\in{\cal M}$. Then the problem, given $M\in{\cal M}$ and a word $x$, determine whether $x\in S(M)$, is undecidable.

Proof 1

Let $M\in{\cal M}$ be a machine with initial state $q_{0}$ and initial store contents $z$ (which can be the concatenation of multiple initial store contents for multi-store machines). Then $q_{0}z$ is in the store language of $M$ if and only if $L(M)$ is not empty.

Hence, membership in $S(M)$ for $M\in{\cal M}$ is undecidable. \qed

This is true for sets of one-way machines, and also two-way machines investigated later in the paper. And in fact, it even holds for complexity classes, such as deterministic Turing machines with a one-way read-only input tape and a logspace bounded worktape (the store). These have a decidable membership problem but an undecidable emptiness problem. Despite the languages accepted by these machines being recursive (and in $\P$), membership in the store language is undecidable (and so there cannot be an effective construction to accept the store languages with another model, such as any model with a decidable membership problem).

Next, store languages of restricted $\NTM$s will be studied. They will be especially useful for characterizing store languages of other machine models. In particular, $\NTM$s with a one-way read-only input tape and one reversal-bounded read/write worktape are considered. In terms of languages accepted, these machines are powerful enough to simulate a number of different machine models exactly, such as one-way nondeterministic reversal-bounded pushdown automata, reversal-bounded queue automata, reversal-bounded stack automata, and reversal-bounded $k$-flip pushdown automata, where the worktape acts exactly like the other stores.

Next, the store languages of these Turing machines are examined. Although $\NTM$s in general have non-regular store languages (investigated in Section 6), when there is only one worktape, and it is reversal-bounded, the store languages are always regular.

Proposition 6

Let $M=(Q,\Sigma,\Gamma,\delta,q_{0},F)$ be an $\NTM$ with a one-way read-only input tape and a reversal-bounded read/write worktape. Then $S(M)\in{\cal L}(\REG)$.

Proof 2

Let $M$ make at most $l$ reversals on the worktape. Note that $L(M)\subseteq\Sigma^{*}$, and $S(M)\subseteq Q\Gamma^{*}$. Let $\Gamma_{0}=\Gamma-\{\downarrow\}$, and $\Gamma_{0}^{\prime}=\{a^{\prime}\mid a\in\Gamma_{0}\}$, a new alphabet (each letter is a “primed” version of a letter in $\Gamma_{0}$, including a primed version of the blank symbol ␣ ). Define a new alphabet $C$ whose symbols have “tracks”, with less than or equal to $(l+2)$-tracks of the form $(a_{1},a_{2},\ldots,a_{p}),p\leq l+2$ where $a_{1}$ is in $\Gamma_{0}\cup\Gamma_{0}^{\prime}\cup Q$ and $a_{i}\in\Gamma_{0}\cup\Gamma_{0}^{\prime}$, for each $i$, $2\leq i\leq p$.

An intermediate 2-way $\NFA$ $M^{\prime}$ is constructed, whose input is in $C^{*}$ delimited with end-markers $\rhd$ and $\lhd$. Thus the input to $M^{\prime}$ is $\rhd w\lhd$, where $w\in C^{*}$. The input $w$ can be thought of as having less than or equal to $l+2$ tracks.

Intuitively, $M^{\prime}$ is trying to verify that the contents of the first track represents a configuration in an accepting computation of $M$, where a symbol $a^{\prime}\in\Gamma_{0}^{\prime}$ is used in place of $a\downarrow$ in the store language. To do this, $M^{\prime}$ nondeterministically guesses an input $x\in\Sigma^{*}$ and simulates $M$ on $x$, track $2$ is verified to be the initial store contents, each track from tracks $3$ to $p-1$ is verified to be the store contents at a point of reversal, and track $p$ is verified to be a final accepting configuration. All tracks are padded by blank symbols to all be of the same length.

Then $M^{\prime}$ operates as follows:

*The first track is verified to contain a word $\leavevmode\hbox{\ignorespaces\verb*!␣! }^{n}qw^{\prime}\leavevmode\hbox{\ignorespaces\verb*!␣! }^{l}$, where $q\in Q,n,l\geq 0$, $w^{\prime}\in\Gamma_{0}^{*}\Gamma_{0}^{\prime}\Gamma_{0}^{*}$ that does not start or end with ␣ * (below, $M^{\prime}$ will verify that the word obtained from $qw^{\prime}$ by replacing $a^{\prime}$ with $a\downarrow$ is in $S(M)$). 2. 2.

$M^{\prime}$* goes to the left end-marker $\rhd$. $M^{\prime}$ checks that the second track contains $\leavevmode\hbox{\ignorespaces\verb*!␣! }^{m}\leavevmode\hbox{\ignorespaces\verb*!␣! }^{\prime}\leavevmode\hbox{\ignorespaces\verb*!␣! }^{r}$ for some $m,r\geq 0$ (the worktape starts off with only blanks, it is implied that all tracks are of length $m+r+1=n+l+|w^{\prime}|+1$).* 3. 3.

$M^{\prime}$* then simulates the $\NTM$ $M$ on a guessed input $x\in\Sigma^{*}$, letter-by-letter, but instead of writing, verifies the next track contents is an updated version of the current track at the next point of reversal. Between the initial configuration and the first reversal, between every two reversals, and between the last reversal and the final configuration, $M^{\prime}$ checks that the contents of track $i+1$ is the updated contents of the worktape from the worktape on track $i$ for $i=2,\ldots,p-1$. To do this, if track $i$ contains $\leavevmode\hbox{\ignorespaces\verb*!␣! }^{\alpha}xa^{\prime}y\leavevmode\hbox{\ignorespaces\verb*!␣! }^{\beta},x,y\in\Gamma_{0}^{*},a\in\Gamma_{0}^{\prime}$, and say $i$ is even (the case is similar if $i$ is odd), then it is verified that track $i+1$ starts with $\leavevmode\hbox{\ignorespaces\verb*!␣! }^{\alpha}x$. Then, if $M$ uses a transition that replaces $a$ with $b$ and moves right on the worktape, then track $i+1$ has $b$ next (a sequence of transitions that stays on the same storage cell are remembered in the finite control), and this simulation continues until $M$ makes a reversal. When $M$ makes a reversal, say from moving right to left, $M^{\prime}$ first “marks” the point of reversal by reading a primed symbol in that position of track $i+1$ (storing the read/write head in track $i+1$), then it moves to the right end-marker and checks that each symbol in track $i$ from the point of reversal to the right end-marker matches the symbols in track $i+1$ (this also implies that track $i+1$ has exactly one symbol from $\Gamma_{0}^{\prime}$). $M^{\prime}$ then moves left back to the point of reversal (which is retrievable from the primed symbol), and resumes the simulation using the next track from the current track.* 4. 4.

At some nondeterministically guessed reversal of the simulation as described in step 3 (say while scanning track $i$, and track $i+1$ reverses from left to right), while $M^{\prime}$ is verifying that track $i+1$ follows from track $i$, in parallel, $M^{\prime}$ verifies that the contents of track 1 is a configuration of the Turing machine between these two reversals. To do this, $M^{\prime}$ remembers the state $q$ on track 1, then compares track $1$ to track $i+1$ symbol-by-symbol, until reaching the read/write head in track 1, where the current state of the simulated machine is verified to be $q$ and the remaining part of track $1$ is verified to be the same as track $i$. Thus, track $1$ is a configuration between tracks $i$ and $i+1$. $M^{\prime}$ then continues the simulation as in step 3.

Since $M^{\prime}$ can only read and not write (on the input), it just verifies the moves and that the changes in the symbols of the $\NTM$ $M$ on track $i$ are reflected in the $i+1$st track. $M^{\prime}$ accepts if $M$ accepts and step 4 above has been successful.

It is known that 2-way $\NFA$s accept only regular languages [20]. Then, apply a gsm [20] to extract just the word $w^{\prime}$ from the first track, erasing blanks appropriately, and replacing any symbol $a^{\prime}\in\Gamma^{\prime}$ by $a\downarrow$. Since regular languages are closed under gsm mappings, the result follows. \qed

As $\NTM$s with a reversal-bounded worktape only give regular store languages, generalizations of these $\NTM$s that still have a decidable emptiness problem are also of interest. In [21], it was shown that such $\NTM$s augmented by reversal-bounded counters have a decidable emptiness problem. Therefore, understanding the store languages of this model is valuable, which is studied next. The proof uses $2\NCM$s, which are two-way nondeterministic reversal-bounded multicounter machines, together with a similar technique as in the proof of Proposition 6, ultimately determining that the store languages are accepted by one-way $\NCM$ machines.

Proposition 7

Let $M$ be an $\NTM$ with a one-way read-only input tape, a reversal-bounded read/write worktape, and $k$ reversal-bounded counters. Then $S(M)\in{\cal L}(\NCM)$.

Proof 3

Here, the store consists of the state, read/write tape, and the values of the counters. The proof of Proposition 6 is generalized (using the same alphabets).

Construct an intermediate $2\NCM$ $M^{\prime}$ that is reversal-bounded on the input tape, with $2k$ reversal-bounded counters.

$M^{\prime}$* will have as input $z=wc_{1}^{i_{1}}\cdots c_{k}^{i_{k}}$ (with end-markers) where $w$ has multiple read-only tracks (over the alphabet $C$, just like in Proposition 6), and the first track is $\leavevmode\hbox{\ignorespaces\verb*!␣! }^{n}qw^{\prime}\leavevmode\hbox{\ignorespaces\verb*!␣! }^{l},q\in Q,n,l\geq 0,w^{\prime}\in\Gamma_{0}^{*}\Gamma_{0}^{\prime}\Gamma_{0}^{*}$ that does not start or end with *␣ . 2. 2.

$M^{\prime}$* simulates $M$’s reversal-bounded read/write worktape on the tracks of the read-only $w$ (as in Proposition 6) and using reversal-bounded counters to simulate the reversal-bounded counters of $M$ faithfully. However, $M^{\prime}$ keeps two copies of each counter, where the two sets of counters are updated synchronously (and are therefore identical during the first part of the simulation).* 3. 3.

At some point, $M^{\prime}$ nondeterministically guesses that the contents of track 1, $qw^{\prime}$ together with counter values $(i_{1},\ldots,i_{k})$ encoded in the input is a representation of a configuration between the current track and the next track. Then, as in Proposition 6, $M^{\prime}$ matches the symbols in the first track with track $i+1$ until the symbol from $\Gamma_{0}^{\prime}$ in track 1, and if so, stops updating one set of the counters. Then $M^{\prime}$ continues by matching track $1$ with track $i$. Then the simulation of $M$ continues, using the other set of counters and on the remaining tracks (as in Proposition 6). At the end of the simulation, $M^{\prime}$ verifies that the non-updated set of counters has the same values as $i_{1},\ldots,i_{k}$ encoded on the input $c_{1}^{i_{1}}\cdots c_{k}^{i_{k}}$. If this is the case, then $qw^{\prime}c_{1}^{i_{1}}\cdots c_{k}^{i_{k}}$ is indeed an intermediate store configuration of an accepting computation, and if so, $M^{\prime}$ accepts.

Now $M^{\prime}$ is a reversal-bounded (on the input) $2\NCM$. Hence, $M^{\prime}$ can be converted to an equivalent one-way $\NCM$ $M^{\prime\prime}$ , i.e., $L(M^{\prime\prime})=L(M^{\prime})$ (this can be done even for the more general finite-crossing $2\NCM$s) [26].

Since ${\cal L}(\NCM)$ is closed under gsm mappings (follows from closure under homomorphism, inverse homomorphism, and intersection with regular languages [1]), construct an $\NCM$ $M^{\prime\prime\prime}$ that applies a gsm that extracts $qw^{\prime}c_{1}^{i_{1}}\cdots c_{k}^{i_{k}}$ (and replaces $a^{\prime}\in\Gamma^{\prime}$ with $a\downarrow$) from the first track of $w$ and $z$. It follows that $S(M)$ is in ${\cal L}(\NCM)$. \qed

It is possible to accept the store languages of other machine models, such as reversal-bounded $\NQCM$ with ${\cal L}(\NCM)$ (this does not follow directly from the fact that such Turing machines can simulate the input languages of this model, as store languages rather than input languages are of interest here).

Proposition 8

If $M$ be a reversal-bounded $\NQCM$, then $S(M)\in{\cal L}(\NCM)$.

Proof 4

Given $M$ with $k$ counters, construct an intermediate $\NTM$ $Z$ with an input tape plus one reversal-bounded read/write worktape, and $k$ additional reversal-bounded counters, whose resulting store language will be in ${\cal L}(\NCM)$ by Proposition 7. $Z$ operates as follows: every time $M$ enqueues $y=b_{1}\cdots b_{m}$, with $b_{i}$ being a letter, $m\geq 1$, $Z$ writes $y$ to the right end of the read/write worktape writing one letter at a time (using new intermediate states) and simulating the counters exactly. Every time $M$ dequeues, $Z$ writes blank characters to the left end of the tape towards the right (thus removing characters from the store of the Turing machine as well). Each time such a reversal occurs (switching between enqueueing and dequeueing), the Turing machine moves its tape head from one end of the tape to the other on new intermediate states. Since the queue is reversal-bounded, the Turing tape is reversal-bounded as well.

The store language of $Z$ has each word of the form $qwc_{1}^{i_{1}}\cdots c_{k}^{i_{k}}$ and is in ${\cal L}(\NCM)$ by Proposition 7. From there, $S(Z)$ will be transformed into $S(M)$ by a gsm $g$. Indeed, the read/write head does not appear explicitly in the store language of the queue nor the blank symbol before the read/write head, whereas it does in the Turing machine, but they can be removed by $g$. Furthermore, if $M$ enqueues more than one symbol ($m>1$), then $Z$ requires $m$ moves. Then all intermediate states used by $Z$ when writing each $b_{i},i<m$ are not mapped by $g$ as they do not have corresponding configurations of $M$. Similarly, the intermediate states that $Z$ uses when it switches between simulating enqueuing and dequeuing instructions (by moving the tape head to the opposite end) are not mapped by $g$. Since ${\cal L}(\NCM)$ is closed under gsm mappings, the store language of $M$ is in ${\cal L}(\NCM)$. \qed

Note that in the proof of the result above, if there are no counters in $M$, then only a Turing machine with one reversal-bounded read/write worktape is required, whose store language is a regular language by Proposition 6.

Corollary 9

If $M$ is a one-way reversal-bounded queue automaton, then $S(M)\in{\cal L}(\REG)$.

Next, it will be shown that the same is true for reversal-bounded stack automata augmented by reversal-bounded counters. Recall that stack automata can operate like pushdown automata with additional instructions that can read in the pushdown store in a read-only fashion [8].

Proposition 10

Let $M$ be a reversal-bounded $\NSCM$ or a reversal-bounded $\NPCM$. Then $S(M)\in{\cal L}(\NCM)$.

Proof 5

Let $M$ be a reversal-bounded stack automaton with $k$ counters. Construct a Turing machine $M^{\prime}$ with a one-way input tape, a reversal-bounded worktape, and $k$ counters. A stack automaton is very similar to a restricted type of Turing machine with a one-way input tape and a worktape to simulate the stack that only changes values at the right end of the tape, except for the following minor differences: instructions that read from the inside of the stack are simulated by transitions that move but do not change from the inside of the Turing tape, the bottom-of-stack marker can be initially placed on the tape, the top of the stack marker is simulated with a blank, and a stack automaton allows to push multiple symbols in one transition. The latter type can be simulated with new intermediate states that push one symbol at a time. The counters are simulated faithfully. Then $S(M^{\prime})\in{\cal L}(\NCM)$, by Proposition 7.

As the intermediate configurations of $M^{\prime}$ that are involved in simulating push transitions of more than one symbol are not configurations of $M$, a gsm can be used to not output on those intermediate configurations (similar to the proof of Proposition 8). From the differences described, it is clear that $S(M)$ is in ${\cal L}(\NCM)$. The proof is similar for $\NPCM$s. \qed

This immediately implies that every reversal-bounded stack automaton has a regular store language, but this result will be improved later in the paper.

Next, a $k$-flip-pushdown automaton is a pushdown automaton, with the ability to flip its store. This can happen at most $k$ times in an accepting computation (see Example 3). Despite the additional ability to flip the store, regularity of the store language is preserved.

Proposition 11

If $M=(Q,\Sigma,\Gamma,\delta,q_{0},F)$, $k\geq 0$ is a one-way $k$-flip pushdown automaton, then $S(M)\in{\cal L}(\REG)$.

Proof 6

For an $\NPDA$ $M^{\prime}$ with state $q$, let $Acc_{M^{\prime}}(q)=\{qx\mid(q_{0},w,Z_{0})\vdash_{M^{\prime}}^{*}(q,\epsilon,x)\}$ and $co\mbox{-}Acc_{M^{\prime}}(q)=\{qx\mid(q,w,x)\vdash_{M^{\prime}}^{*}(q_{f},\epsilon,x^{\prime}),q_{f}\in F\}$. That is, $Acc_{M^{\prime}}(q)$ is the set of store contents in state $q$ that are reachable from the initial configuration, and $co\mbox{-}Acc_{M^{\prime}}(q)$ is the set of store contents in state $q$ that can reach an accepting configuration. It is known that for $\NPDA$s $M^{\prime}$ and all states $q$, both $Acc_{M^{\prime}}(q)$ and $co\mbox{-}Acc_{M^{\prime}}(q)$ are regular [2].

Every instruction of a $k$-flip $\NPDA$ is either a standard $\NPDA$ instruction or a flip instruction, as defined in Example 3, and at most $k$ flip instructions can be applied in every accepting computation. First, note that the store language $S(M)$ is the union of the store languages obtained using each final state separately. Since the regular languages are closed under union, assume without loss of generality that $M$ only has one final state $q_{f}$.

Consider any computation of $M$, not necessarily from an initial configuration nor to an accepting configuration,

[TABLE]

$r_{j}\in Q,w_{j}\in\Sigma^{*},\gamma_{j}\in Z_{0}\Gamma_{0}^{*}$, for $0\leq j\leq m$ using at most $k$ flips. From $\alpha$, there is a sequence, denoted by

[TABLE]

such that $\alpha$ has $l\leq k$ flip transitions, and the $i$’th flip transition applied is from $p_{2i-1}$ to $p_{2i}$, for all $1\leq i\leq l$. Also, if $\alpha$ is an accepting computation (starting from an initial configuration and ending in an accepting configuration), let $S_{\alpha}(M)=\{r_{0}\gamma_{0},\ldots,r_{m}\gamma_{m}\}$. This is generalized to sets of accepting derivations $Y$, as $S_{Y}(M)$.

Let $X$ be the finite set of all sequences $z=p_{1},\ldots,p_{2l}$, where $l\leq k$, and there is some transition of $M$ that flips while switching from $p_{2i-1}$ to $p_{2i}$, for all $i$. Given any $z\in X$, let $g(z)$ be the set of all accepting computations $\alpha$ of $M$ such that $f(\alpha)=z$. It is clear that $S(M)=\bigcup_{z\in X}S_{g(z)}(M)$. Thus, it is enough to show that, for each $z\in X,S_{g(z)}(M)$ is regular.

Let $z=p_{1},\ldots,p_{2l}\in X$. Then each word in $S_{g(z)}(M)$ is either derived from a configuration between the $j$’th flip and the $(j+1)$’st flip, for $0\leq j<l$, or after the $l$’th flip (and before the end). For $0\leq j\leq l$, let $S_{g(z),j}$ be all those store contents between the $j$’th flip (or the beginning if $j=0$) and the transition before the $j+1$’st flip (or the end of the computation if $j=l$). Again, if each $S_{g(z),j}(M)$ is regular, then $S_{g(z)}(M)$ is regular. Let $0\leq j\leq l$. For each $i$ from [math] to $j$, let $z_{i}=p_{1},\ldots,p_{2i}$ (if $i=0$, then there are no flip transitions), and let $Acc_{i}(q)=\{qx\mid\alpha:(q_{0},w,Z_{0})\vdash^{*}(q,\epsilon,x),\alpha\in g(z_{i})\}$. It will be shown that each $Acc_{i}(q)$ is regular. This will be done by building an $\NPDA$ $M^{\prime}$ without flips such that $Acc_{M^{\prime}}(q)=Acc_{i}(q)$, which then must be regular. This is done inductively on $z_{i}$.

Consider the $\NPDA$ $M_{0}$ obtained from $M$ by keeping all $\NPDA$ transitions but omitting flip transitions. Then $Acc_{M_{0}}(p_{1})=Acc_{0}(p_{1})$ is regular. Hence, $Y_{1}=p_{2}Z_{0}((p_{1}Z_{0})^{-1}Acc_{0}(p_{1}))^{R}$ is regular as well (since the regular languages are closed under left quotient, concatenation, and reversal. This is exactly the set of store contents that can be derived from those in $Acc_{0}(p_{1})$ via a flip transition from $p_{1}$ to $p_{2}$. Then build another $\NPDA$ $M_{1}$ that pushes an arbitrary word of $Y_{1}$, then simulates $M$ without flips until $p_{3}$. Then $Acc_{M_{1}}(p_{3})=Acc_{1}(p_{3})$, which is again regular. This same procedure proceeds inductively by reversing the regular store language until an $\NPDA$ $M_{j}$ can be built such that for each $p\in Q$, $Acc_{M_{j}}(p)=Acc_{j}(p)$, which is regular.

Similarly, for each $i$ from $j$ to $l$, let $z_{i}=p_{2i+1},\ldots,p_{2l}$, and $co\mbox{-}Acc_{i}(q)=\{qx\mid\alpha:(q,w,\gamma)\vdash^{*}(q_{f},\epsilon,\gamma^{\prime}),\alpha\in g(z_{i})\}$. In a similar fashion, for each $p\in Q,co\mbox{-}Acc_{M_{j}}(p)=co\mbox{-}Acc_{j}(p)$, which is again regular. Furthermore, $\bigcup_{p\in Q}(Acc_{j}(p)\cap co\mbox{-}Acc_{j}(p))=S_{g(z),j}(M)$. Hence, $S_{g(z),j}(M)$ is regular, $S_{g(z)}(M)$ is regular, and $S(M)$ is regular. \qed

This is indeed quite a general family to have only regular store languages.

Next, the store languages of $\NCM$s are analyzed. Surprisingly, only deterministic machines in $\DCM$ are needed to accept them.

Proposition 12

If $M$ is an $\NCM$, then $S(M)\in{\cal L}(\DCM)$. Thus, ${\cal S}(\NCM)\subsetneq{\cal L}(\DCM)$.

Proof 7

Let $M$ have counters $C_{1},\ldots,C_{k}$. First, construct an intermediate $\NCM$ $M^{\prime}$ with counters named $C_{1},\ldots,C_{k},D_{1},\ldots,D_{k}$ to accept $S(M)$. Then $M^{\prime}$, when given an input $z$, checks that $z$ is of the form $qc_{1}^{i_{1}}\cdots c_{k}^{i_{k}}$ for a state $q$, $i_{1},\ldots,i_{k}\geq 0$ (this can be done by a $\DFA$ in parallel). To check that $z$ is in $S(M)$, on transitions that do not read any input, $M^{\prime}$ guesses an input $x$ to $M$ in a letter-by-letter fashion and simulates $M$ on $x$ using counters $C_{1},\ldots,C_{k}$ and $D_{1},\ldots,D_{k}$ (i.e., $D_{1},\ldots,D_{k}$ are duplicate counters which operate like $C_{1},\ldots,C_{k}$ similar to Proposition 7 step 2). At some point (nondeterministically chosen), $M^{\prime}$ stops updating counters $D_{1},\ldots,D_{k}$ and remembers the current state $q^{\prime}$ but continues the simulation with counters $C_{1},\ldots,C_{k}$. When $M$ accepts, $M^{\prime}$ checks that the value in counter $D_{j}$ is $i_{j}$ (from the input), for all $j$, $1\leq j\leq k$ and that $q=q^{\prime}$. Hence, $S(M)=L(M^{\prime})$. The $\NCM$ $M^{\prime}$ can then be converted to a $\DCM$ $M^{\prime\prime}$, since it is known that any $\NCM$ accepting a bounded language can be accepted by a $\DCM$ [27]. \qed

Although all store languages of the nondeterministic model $\NCM$ can be accepted by the deterministic model $\DCM$, next, it will be shown that this is not the case for $\DPCM$.

Proposition 13

Let $M$ be an $\NCM$ which accepts with all counters zero and in a unique accepting state $f$ which is never re-entered. Let $L=fZ_{0}L(M)$. Then there is a 0-reversal-bounded $\DPCM$ $M^{\prime}$ and a regular language $R$ such that $L=S(M^{\prime})\cap R$. Then $L(M)=(fZ_{0})^{-1}S(M^{\prime})$.

Proof 8

Let $M$ be an $\NCM$ with $k$ counters and input alphabet $\Sigma$. Represent each transition of $M$ by an abstract symbol:

[TABLE]

where $p$ and $q$ are states, $a$ is either in $\Sigma$ or $\epsilon$, $d_{i}$ represents the status (zero or non-zero) of counter $i$, and $y_{i}$ is the change in counter $i$. Let $\Delta$ be the set of symbols representing the transitions.

The input alphabet of the $\DPCM$ $M^{\prime}$ is $\Delta$. For a string $y\in\Delta^{*}$, let $x$ be the concatenation of the the input components of the transitions in $y$. On input $y$, $M^{\prime}$ writes $x$ on the stack while simulating the computation of $M$ on $x$ using the counters, and accepts in state $f$ if $M$ accepts $x$. $M^{\prime}$ is indeed deterministic since each symbol of $\Delta$ implies the transition to apply.

Hence, $S(M^{\prime})$ contains all strings of the form $fZ_{0}w$, where $w$ is in $L(M)$. Let $R$ be the regular language $fZ_{0}\Sigma^{*}$. Then $L=S(M^{\prime})\cap R$, and $L(M)=(fZ_{0})^{-1}S(M^{\prime})$. \qed

From this, the following is true:

Proposition 14

There is a 0-reversal-bounded $\DPCM$ $M$ such that $S(M)$ cannot be accepted by any $\DPCM$.

Proof 9

Suppose otherwise. It is known that there are languages in ${\cal L}(\NCM)$ that are not in ${\cal L}(\DPCM)$ [28]. Let $L$ be such a language accepted by some $M\in\NCM$. By Proposition 13, there exists $M^{\prime}\in\DPCM$ that is [math]-reversal-bounded such that $(fZ_{0})^{-1}S(M^{\prime})=L(M)$. But $S(M^{\prime})\in{\cal L}(\DPCM)$ by the assumption. Also, it is clear that ${\cal L}(\DPCM)$ is closed under left quotient with a fixed word as a $\DPCM$ can simulate first on the fixed word deterministically, then on the input deterministically. Hence, $L(M)\in{\cal L}(\DPCM)$, a contradiction. \qed

Lastly, two results will be stated that are shown below in Section 4.1 and Section 4.2 respectively, which are results on one-way stack automata, but require results on two-way automata for their proofs. The first is already known [10].

Proposition 15

[10]** If $M$ is a one-way nondeterministic stack automaton, then $S(M)\in{\cal L}(\REG)$.

Proposition 16

There exists $M\in\NSCM$ with one $1$-reversal-bounded counter over a unary alphabet such that $S(M)\notin{\cal L}(\NPCM)$.

The latter result is interesting in the following sense: an $\NSCM$ combines a stack and reversal-bounded counters. A stack alone yields only regular store languages; but the store languages of $\NSCM$ are more general, describing some languages that are neither in ${\cal L}(\NCM)$ nor ${\cal L}(\NPCM)$. However, it is seen next that $\NSCM$s only yield $\NSCM$ store languages.

Proposition 17

If $M\in\NSCM$, then $S(M)\in{\cal L}(\NSCM)$.

Proof 10

Let $M$ be a $k$-counter $\NSCM$. Construct a $2k+2$ counter $\NSCM$ machine $M^{\prime}$ (give names $c_{i},d_{i},e,f$ to the counters, $1\leq i\leq k$) to accept $S(M)$ that simulates $M$ with two identical copies of each counter, $c_{i}$ and $d_{i}$, $1\leq i\leq k$, on a guessed input. Then, at some nondeterministically guessed spot, $M^{\prime}$ verifies that the stack contents are the same as the input by moving the stack head to the left-end-marker while adding one to counter $e$ and $f$, then $M^{\prime}$ verifies that the stack contents are the same as the input by comparing the stack to the input symbol-by-symbol while decreasing $e$ to verify that the read/write head on the input is in the correct location. Then $M^{\prime}$ returns its stack read head to the proper location using counter $f$. Then $M^{\prime}$ verifies that the counter values match the input values by decreasing each $c_{i}$. Finally, $M^{\prime}$ continues the simulation on the second set of counters, $d_{i}$, accepting if $M$ accepts. \qed

3.2 Connections Between Deterministic and Nondeterministic Machines

Thus far, the primary concern has been store languages of nondeterministic machine models. In this section, a connection between deterministic and nondeterministic one-way machines is demonstrated. A store type is said to have stay instructions if there are instructions to keep the store the same (that do not violate the instruction language). All store types considered in this paper are of this form.

Proposition 18

Let $\Omega_{1},\ldots,\Omega_{k}$ be store types with stay instructions, and let $M$ be a one-way nondeterministic $(\Omega_{1},\ldots,\Omega_{k})$-machine. One can construct a one-way deterministic $(\Omega_{1},\ldots,\Omega_{k})$-machine acceptor $M^{\prime}$ of the same type as $M$ such that $S(M^{\prime})=S(M)$.

Proof 11

Let $t_{1},\ldots,t_{m}$ be new symbols in bijective correspondence with the transitions of $M$. Then let $M^{\prime}$ operate as follows over the input alphabet $T=\{t_{1},\ldots,t_{m}\}$, with the same state set, initial state, and final state set, and the transition function $\delta^{\prime}$ is as follows: for each transition of $M$, $t_{i}:(p,\iota_{1},\ldots,\iota_{k})\in\delta(q,a,d_{1},\ldots,d_{k}),a\in\Sigma\cup\{\epsilon\}$, create a transition of $M^{\prime}$ $(p,\iota_{1},\ldots,\iota_{k})\in\delta^{\prime}(q,t_{i},d_{1},\ldots,d_{k})$. Also, create transitions that stay from any final state while reading the end-marker. Thus, consider any accepting computation of $M$ using a sequence of transitions. Then reading the corresponding sequence labels with $M^{\prime}$ (followed by reading the end-marker) is an accepting computation with the store changing identically (thus, it is in the instruction language). Similarly, given any accepting computation of $M^{\prime}$, applying this sequence accepted by $M^{\prime}$ as a sequence of transitions of $M$ is accepting with the store changing identically. Hence, $S(M^{\prime})=S(M)$. Also, $M^{\prime}$ is deterministic since the input symbol dictates the transition to apply. \qed

Also, note in Proposition 18 that $M^{\prime}$ operates in realtime.

Corollary 19

The following are true: ${\cal S}(\NPDA)={\cal S}(\DPDA)$ and ${\cal S}(\NCM)={\cal S}(\DCM)$

This is also true for all one-way nondeterministic and deterministic machine models considered in this paper.

Finally, it is interesting to consider whether store languages of machine models can always be accepted by only deterministic machines of the same type. Indeed, the following are true:

If $M$ is an $\NFA$ or an $\NPDA$, then $S(M)$ is regular and hence the deterministic version of the model can accept its own store language. 2. 2.

If $M$ is an $\NCM$, then $S(M)$ can be accepted by a $\DCM$, hence the deterministic version of the model can accept its own store language.

However, it follows from Proposition 14 that the store languages of $\DPCM$s cannot be accepted by $\DPCM$s.

4 Machines with Two-Way Read-Only Inputs

Using exactly the same store types as defined in the previous section, two-way input machines can also be defined. Given store types $\Omega_{1},\ldots,\Omega_{k}$ with $\Omega_{i}=(\Gamma_{i},I_{i},f_{i},g_{i},c_{0,i},L_{I,i}),1\leq i\leq k$, two-way inputs have an end-marker on both sides, $\rhd w\lhd$, and the finite transition relation is from $Q\times(\Sigma\cup\{\rhd,\lhd\})\times\Gamma_{1}\times\cdots\times\Gamma_{k}$ to $Q\times I_{1}\times\cdots\times I_{k}\times\{-1,0,+1\}$ (with the last component describing the direction of the input head movement), a configuration of $M$ is a tuple $(q,\rhd w\lhd,\gamma_{1},\ldots,\gamma_{k},j)$, where $q\in Q,w\in\Sigma^{*},\gamma_{i}\in\Gamma_{i}^{*},1\leq j\leq|w|+3$ giving the current position on the input (position $1$ is $\rhd$, $|w|+2$ is $\lhd$, and $|w|+3$ is off the input tape). The derivation relation $\vdash_{M}$ is defined by: $(q,\rhd w\lhd,\gamma_{1},\ldots,\gamma_{k},j)\vdash_{M}(q^{\prime},\rhd w\lhd,\gamma_{1}^{\prime},\ldots,\gamma_{k}^{\prime},j^{\prime})$ if there exists $(q^{\prime},\iota_{1},\ldots,\iota_{k},n)\in\delta(q,a,d_{1},\ldots,d_{k})$, $a$ is the $j$’th character of $\rhd w\lhd$, $j^{\prime}=j+n,g(\gamma_{i})=d_{i},f(\gamma_{i},\iota_{i})=\gamma_{i}^{\prime}$, for each $i$, $1\leq i\leq k$. Validity is defined just like with one-way machines. The language accepted by $M$, $L(M)=\{w\mid(q_{0},\rhd w\lhd,c_{0,1},\ldots,c_{0,k},1)\vdash_{M}^{x}(q_{f},\rhd w\lhd,\gamma_{1},\ldots,\gamma_{k},j),q_{f}\in F,w\in\Sigma^{*},\gamma_{i}\in\Gamma_{i}^{*},1\leq j\leq|w|+3,x\mbox{~{}is valid}\}$. The store language of $M$, $S(M)$ is equal to $\{q\gamma_{1}\cdots\gamma_{k}\mid(q_{0},\rhd w\lhd,c_{0,1},\ldots,c_{0,k},1)\vdash_{M}^{x}(q,\rhd w\lhd,\gamma_{1},\ldots,\gamma_{k},j)\vdash_{M}^{y}(q_{f},\rhd w\lhd,\gamma_{1}^{\prime},\ldots,\gamma_{k}^{\prime},j^{\prime}),q\in Q,q_{f}\in F,\gamma_{i},\gamma_{i}^{\prime}\in\Gamma_{i}^{*},j,j^{\prime}\in\{1,\ldots,|w|+3\},xy\mbox{~{}is valid}\}$.

In the previous section, store languages of different types of machines with a one-way read-only input were studied. The rest of this section will investigate store languages of machine models with two-way inputs.

4.1 Two-Way $\NCM$s and $\DCM$s

This subsection considers store languages of two-way $\NCM$s ($2\NCM$s) and two-way $\DCM$s (2$\DCM$s). A machine is finite-crossing if there is a $d\in\mathbb{N}$ such that in any computation, the input head crosses the boundary between any two adjacent cells of the input no more than $d$ times. The first result demonstrates the surprising fact that the store languages of finite-crossing $2\NCM$s can always be accepted by machines that are only one-way and deterministic.

Proposition 20

If $M$ is a finite-crossing $2\NCM$, then $S(M)\in{\cal L}(\DCM)$.

Proof 12

Given a $k$-counter finite-crossing $2\NCM$ $M$ over $\Sigma$, first, construct an intermediate finite-crossing $2\NCM$ $M_{1}$ with $2k+1$ counters and input of the form $xqc_{1}^{i_{1}}\cdots c_{k}^{i_{k}}$, where $x\in\Sigma^{*}$.

$M_{1}$* simulates the computation of $M$ on $x$ with two sets of counters named $C_{j}$ and $D_{j}$ for $1\leq j\leq k$ so that $C_{j}$ and $D_{j}$ contain identical values. At some nondeterministically chosen point, $M_{1}$ stores the input head position in the remaining counter, checks that the input segment $qc_{1}^{i_{1}}\cdots c_{k}^{i_{k}}$ corresponds to the simulated state and the value $i_{j}$ is equal to the value stored in counter $D_{j}$, for each $1\leq j\leq k$. If so, $M_{1}$ continues the simulation of $M$ on the correct position of $x$ (which can be recovered) using the $C_{1},\ldots,C_{k}$ counters, and accepts if and only if $M$ accepts. It is known that all finite-crossing $2\NCM$s can be converted to one-way $\NCM$s [26], and so convert $M_{1}$ to an $\NCM$ $M_{2}$ and then construct an $\NCM$ $M_{3}$ that erases the $x$ [1] (${\cal L}(\NCM)$ is closed under homomorphisms and therefore $x$ can be erased). Then convert $M_{3}$ to a $\DCM$ $M_{4}$ as all bounded $\NCM$ languages are in ${\cal L}(\DCM)$ [27]. \qed*

Without the finite-crossing condition, this no longer holds.

Proposition 21

There is a non-finite-crossing $2\DCM$ $M$ with one $1$-reversal counter over the bounded language $a^{*}b^{*}$ such that $S(M)\notin{\cal L}(\NPCM)$.

Proof 13

Construct $2\DCM$ $M$ with one $1$-reversal counter accepting $\{a^{i}b^{j}\mid i,j>1,i\neq j,i\mbox{~{}is a multiple of~{}}j\}$ as follows: $M$ stores $i$ in counter $C$ and enters a distinguished state $f$. (Thus, the configuration at this time is $fc_{1}^{i}$.) Then $M$ changes state and checks (by decrementing $C$ while going back-and-forth on $b^{j}$ at least twice) if $i$ is divisible by $j$, and if so, $M$ accepts. Clearly, $M$’s counter makes only one reversal.

It follows from the construction that if $i$ is a multiple of $j$ and $i\neq j$, then $fc_{1}^{i}$ would be a reachable configuration in some accepting computation.

Hence, $S(M)\cap fc_{1}^{*}=\{fc_{1}^{n}\mid n$ is composite$\}$.

If $S(M)$ is in ${\cal L}(\NPCM)$, then $L^{\prime}=S(M)\cap fc_{1}^{*}=\{fc_{1}^{n}\mid n\mbox{~{}is composite}\}$ is in ${\cal L}(\NPCM)$. This is a contradiction, since the Parikh map of $L^{\prime}$ is not semilinear, but it is known that the Parikh map of any $\NPCM$ language is semilinear [1]. \qed

For nondeterministic machines, only a unary alphabet is needed to obtain a similar result.

Proposition 22

There is a non-finite crossing $2\NCM$ $M$ with one $1$-reversal counter over a unary alphabet such that $S(M)\notin{\cal L}(\NPCM)$.

Proof 14

Construct an $M$ which first stores in the counter, a nondeterministically chosen number $n$ and enters state $f$. Then it changes state and checks that $n$ is larger and a multiple of the length of the unary input. As in Proposition 21, $S(M)$ is not in ${\cal L}(\NPCM)$. \qed

The next result was already mentioned in Section 3, but the proof appears here since it involves a proof using two-way machines.

Proposition 23

There exists $M\in\NSCM$ with one $1$-reversal-bounded counter over a unary alphabet such that $S(M)\notin{\cal L}(\NPCM)$.

Proof 15

Let $M$ be a $2\NCM$ with one $1$-reversal-bounded counter over a unary language such that $S(M)\notin{\cal L}(\NPCM)$, which exists by Proposition 22. Create an $\NSCM$ $M^{\prime}$ with one counter, where $M^{\prime}$ copies the input to the stack (using new states), and then simulates $M$ on the stack contents and the counter. Assume $S(M^{\prime})\in{\cal L}(\NPCM)$. Let $g$ be a gsm that erases the stack contents (keeping only the state and the counter), and $g$ does not map any words starting with any new state before the input is copied. Then $g(S(M^{\prime}))=S(M)\in{\cal L}(\NPCM)$ since this family is closed under homomorphism, inverse homomorphism, and intersection with regular languages [1], and is therefore closed under gsm mappings, a contradiction. \qed

This subsection is concluded with a result that shows that for a particular two-way model of computation, the store languages can be more complex than the languages accepted.

Proposition 24

**

If $M$ is a $2\NCM$ over a unary input alphabet, then $L(M)$ is regular. 2. 2.

There is a $2\NCM$ $M$ with one 1-reversal-bounded counter over a unary input alphabet such that $S(M)$ is not semilinear (hence, $S(M)$ is not regular).

Proof 16

Part 1 was shown in [29]. Part 2 follows from the language used in the proof of Proposition 22. \qed

Hence, the languages accepted by the machines are all regular, but the store languages are not even semilinear.

4.2 Connections Between One-Way and Two-Way Machines

This subsection establishes some general connections between one-way and two-way machines. First, a straightforward lemma is demonstrated to show that store languages of one-way nondeterministic machines are equivalent to those only accepting the empty word.

Lemma 25

Let $\Omega_{1},\ldots,\Omega_{k}$ be store types, and let ${\cal M}$ be the set of one-way nondeterministic $(\Omega_{1},\ldots,\Omega_{k})$-machines. If $M\in{\cal M}$, then there exists $M^{\prime}\in{\cal M}$ such that $L(M^{\prime})=\{\epsilon\}$ and $S(M^{\prime})=S(M)$. Hence, the family $\{S(M)\mid M\in{\cal M}\}=\{S(M)\mid M\in{\cal M},L(M)=\{\epsilon\}\}$.

Proof 17

Construct $M^{\prime}$ which, on $\epsilon$ input, guesses and simulates the computation of $M$ on some input $x$ symbol-by-symbol. Since the sequence of ways the store can change is the same as in $M$, then $M^{\prime}$ must be an $(\Omega_{1},\ldots,\Omega_{k})$-machine (i.e. in the definition of store types, all sequences of store instructions used in $M$ in accepting computations are the same for $M^{\prime}$, thereby being in the instruction language), and so $S(M)=S(M^{\prime})$. \qed

The above lemma is not true for deterministic machines $M$, since $S(M)$ may be infinite, but if $L(M^{\prime})$ only accepts $\epsilon$, then $S(M^{\prime})$ for any deterministic machine $M^{\prime}$ is always finite.

Next, a connection will be demonstrated between sets of one-way and two-way machines of the same store type. The proposition involves two sets of machines with the same stores, where the first has a one-way input, and the second has a two-way input. For example, if ${\cal M}_{1}$ is the class of $\NPDA$s with $k$ reversal-bounded counters, then ${\cal M}_{2}$ is the class of $2\NPDA$s with $k$ reversal-bounded counters. It shows that the store languages for one-way machines are “almost” the same as two-way machines of the same type. The only difference is in the state.

Proposition 26

Let $\Omega_{1},\ldots,\Omega_{k}$ be store types, let ${\cal M}_{1}$ be the set of one-way nondeterministic $(\Omega_{1},\ldots,\Omega_{k})$-machines and let ${\cal M}_{2}$ be the set of two-way nondeterministic $(\Omega_{1},\ldots,\Omega_{k})$-machines. Then the following are true:

$\{S(M)\mid M\in{\cal M}_{1}\}=\{S(M)\mid M\in{\cal M}_{1},L(M)=\{\epsilon\}\}\subseteq\{S(M)\mid M\in{\cal M}_{2},L(M)=\{\epsilon\}\}$. 2. 2.

For all $M_{2}\in{\cal M}_{2}$ with $L(M_{2})$ finite, there exists $M_{1}\in{\cal M}_{1}$ with $L(M_{1})=\{\epsilon\}$ and a homomorphism $h$ (that only can change the states) such that $h(S(M_{1}))=S(M_{2})$.

Proof 18

For item 1, from Lemma 25, $\{S(M)\mid M\in{\cal M}_{1}\}=\{S(M)\mid M\in{\cal M}_{1},L(M)=\{\epsilon\}\}$. Then, for every machine in the second set, a two-way machine can be constructed (on epsilon input and thus the two-way head never moves off end-markers) with the same store language.

For item 2, let $M_{2}\in{\cal M}_{2}$. For each $w\in L(M_{2})$, there exists $S_{w}(M_{2})$ consisting of all words $x\in S(M_{2})$ that can appear on the store in an accepting computation on input $w$. Then $\bigcup_{w\in L(M_{2})}S_{w}(M_{2})=S(M_{2})$.

Construct a machine $M_{1}$ in ${\cal M}_{1}$ as follows: $M_{1}$ stores in its state a simulated state of $M_{2}$, a word $w\in L(M)$, and a position of $|w|$. In the first move applied, $M_{1}$ guesses $w$, and simulates $M_{2}$ on $w$ by updating the state, the stored input position, and the stores faithfully. As the sequences of store instructions are identical, and sequences of valid instructions of one machine will have the corresponding sequence in the other machine be valid. Finally, although the stores change identically in accepting computations, the states of $M_{1}$ are different, as they contain also a word and a position. But those can be transformed via a homomorphism $h$ that projects onto the simulated state. Thus, $h(S(M_{1}))=S(M_{2})$. \qed

Corollary 27

Let $\Omega_{1},\ldots,\Omega_{k}$ be store types, let ${\cal M}_{1}$ be the set of all one-way nondeterministic $(\Omega_{1},\ldots,\Omega_{k})$-machines and let ${\cal M}_{2}$ be the set of all two-way nondeterministic $(\Omega_{1},\ldots,\Omega_{k})$-machines, and let ${\cal L}$ be a family closed under homomorphism. Then the following are equivalent:

$\{S(M)\mid M\in{\cal M}_{1}\}\subseteq{\cal L}$, 2. 2.

$\{S(M)\mid M\in{\cal M}_{1},L(M)=\{\epsilon\}\}\subseteq{\cal L}$, 3. 3.

$\{S(M)\mid M\in{\cal M}_{2},L(M)\mbox{~{}finite}\}\subseteq{\cal L}$.

As applications of the above, the following corollaries to the results already shown in Section 3 are obtained:

If $M$ is a $2\NPDA$ and $L(M)$ is finite, then $S(M)$ is regular. 2. 2.

If $M$ is a $2\NTM$ with reversal-bounded read/write tape and $L(M)$ is finite, then $S(M)$ is regular. 3. 3.

If $M$ is a $2\NTM$ with reversal-bounded read/write tape and reversal-bounded counters and $L(M)$ is finite, then $S(M)$ is in ${\cal L}(\NCM)$.

Similar corollaries hold for the other machine models studied in Section 3.

The assumption that $L(M_{2})$ is finite in the above Proposition 26 is necessary. Consider $2\DCA$, the set of two-way deterministic machines with an unrestricted counter (no reversal-bound).

Proposition 28

There is a $2\DCA$ $M$ which makes two sweeps on the input (left-to-right and then right-to-left, where acceptance is on the left end-marker) and makes only $O(\log n)$ reversals on the counter on input of size $n$ such that $S(M)$ is non-regular.

Proof 19

Construct $M$ which, when given input $w$, operates as follows:

$M$* makes a left-to-right sweep of the input $w$ and checks that it is of the form*

[TABLE]

for some $k\geq 1,i_{1},\ldots,i_{k},j_{1},\ldots,j_{k}\geq 1$. It uses the counter to check that $i_{i}=j_{1},\ldots,i_{k}=j_{k}$. At the end of this process, the counter is zero. 2. 2.

Then $M$ moves its input head left and increments the counter to value $i_{k}(=j_{k})$ and enter a unique state $f$. Thus the configuration of the counter and state at this time is $fc_{1}^{i_{k}}$. The state $f$ is only entered at this time. 3. 3.

Next, $M$ continues moving left checking that $j_{k-1}=i_{k}/2,j_{k-2}=i_{k-1}/2,\ldots,j_{1}=i_{2}/2=1$ and accepts. (This is possible because there are two copies of $i_{k}$ in each block.)

$S(M)$* is non-regular; otherwise $S(M)\cap fc_{1}^{+}=f\{c_{1}^{2^{n}}~{}|~{}n\geq 1\}$ would be regular. Clearly $M$ makes $O(\log n)$ reversals on the counter. *\qed

Hence, the store languages of one-way $\DCA$s are regular by Proposition 4, but two-way $\DCA$s are not.

Next, the store language of two-way and one-way nondeterministic stack automata will be addressed. In [10], it was shown that the store language of a one-way stack automaton is regular. Here, an alternative simple proof of this result is provided by using the general connections established between one-way automata and two-way automata in Corollary 27, and an existing older result on two-way stack automata. In [8], it was shown that the set of all words that can appear in the store of a two-way stack automaton $M$ on an input $w\in\Sigma^{*}$ (not in general over all words, but over only a single word), when $M$ “falls off” the right end-marker of $w$, is a regular language (this was used as a key step to showing all two-way stack languages are recursive). This fact will be combined with the results of this section to show that all store languages of one-way nondeterministic stack automata are regular. Two technical lemmas are required before a proof of the main result (essentially used to convert the notation used in [8] to our notation).

Lemma 29

Let $M$ be a two-way nondeterministic stack automaton. Then $\{qx\downarrow y\mid(q_{0},\rhd\lhd,Z_{0}\downarrow,1)\vdash^{*}(q,\rhd\lhd,x\downarrow y,1)\}\in{\cal L}(\REG)$.

Proof 20

In [8], it is shown that, for each word $\rhd w\lhd$, and each $q\in Q$ then $\{xqy\mid(q_{0},\rhd w\lhd,Z_{0}\downarrow,1)\vdash^{*}(q,\rhd w\lhd,x\downarrow y,|w|+3)\}$ is a regular language. Then it is clear that, using the empty word, $\{qx\downarrow y\mid(q_{0},\rhd\lhd,Z_{0}\downarrow,1)\vdash^{*}(q,\rhd\lhd,x\downarrow y,3)\}$ is regular.

Let $M^{\prime}$ be a new two-way nondeterministic stack machine with state set $Q\cup Q^{\prime}$, $Q^{\prime}=\{q^{\prime}\mid q\in Q\}$ (primed versions). Then $M^{\prime}$ simulates $M$, but at any nondeterministically chosen step, if the simulated $M$ is in state $q$, $M^{\prime}$ can nondeterministically switch to $q^{\prime}$ and move the input head past the right end-marker using a new state $q^{\prime}$. Then $X=\{q^{\prime}x\downarrow y\mid(q_{0},\rhd\lhd,Z_{0}\downarrow,1)\vdash_{M^{\prime}}^{*}(q^{\prime},\rhd\lhd,x\downarrow y,3),q^{\prime}\in Q^{\prime}\}$ which is regular. Let $h$ be a homomorphism that maps each $q^{\prime}\in Q^{\prime}$ to $q$ and fixes all other letters. Indeed, $h(X)=\{qx\downarrow y\mid(q_{0},\rhd\lhd,Z_{0}\downarrow,1)\vdash_{M}^{*}(q,\rhd\lhd,x\downarrow y,1)\}\in{\cal L}(\REG)$. \qed

Lemma 30

Let $M=(Q,\Sigma,\Gamma,\delta,q_{0},F)$ be a two-way nondeterministic stack automaton. Then $\{qx\downarrow y\mid(q,\rhd\lhd,x\downarrow y,1)\vdash_{M}^{*}(q_{f},\rhd\lhd,z,1),q_{f}\in F,z\in\Gamma^{*}\}\in{\cal L}(\REG)$.

Proof 21

In a standard proof that shows a one-way nondeterministic stack automaton is closed under reversal, from an automaton $M$, another $M^{\prime}$ is constructed that guesses the final stack contents and pushes it while also guessing the position of the read head inside (using new states), guesses a final state of $M$, then simulates $M$ “in reverse”; if $M$ pushes, $M^{\prime}$ pops; if $M$ pops, $M^{\prime}$ pushes, if $M$ moves left in the stack, $M^{\prime}$ moves right, etc. The same construction works for two-way nondeterministic stack automata on $\epsilon$ input.

Hence, from $M$, let $M^{\prime}=(Q^{\prime},\Sigma,\Gamma,\delta^{\prime},q_{0}^{\prime},F^{\prime})$ be a new two-way nondeterministic stack automaton constructed in this way. It does not ever move its input head, and on a new initial state $q_{0}^{\prime}$, nondeterministically guesses a word $z$ and puts it on the stack, then on another new state $q_{1}^{\prime}$, moves the read head of the stack to an arbitrary position inside (thus guessing $z_{1}\downarrow z_{2}$), then $M^{\prime}$ nondeterministically switches to any final state of $M$. From there, $M^{\prime}$ simulates $M$ in reverse. So, if $M$ moves right in the stack, then $M^{\prime}$ moves left, if $M$ moves left, then $M^{\prime}$ moves right. If $M$ replaces the top of the stack symbol $x$ with $b_{1}\cdots b_{m},m\geq 1$, then $M^{\prime}$ pops $b_{m}$ down to $b_{2}$ (using states not in $Q$), then replaces $b_{1}$ with $x$. If $M$ pops $x$, then $M^{\prime}$ pushes $x$, etc.

Then, $X=\{qx\downarrow y\mid(q_{0}^{\prime},\rhd\lhd,Z_{0}\downarrow,1)\vdash_{M^{\prime}}^{*}(q,\rhd\lhd,x\downarrow y,1),q\in Q^{\prime}\}$ is regular by Lemma 29. Furthermore, $X\cap Q\Gamma^{*}$ is regular (thus omitting configurations reached on any new states is also regular since regular languages are closed under intersection). This set is equal to $\{qx\downarrow y\mid(q_{0}^{\prime},\rhd\lhd,Z_{0}\downarrow,1)\vdash_{M^{\prime}}^{*}(q_{1}^{\prime},\rhd\lhd,z_{1}\downarrow z_{2},1)\vdash_{M^{\prime}}(q_{f},\rhd\lhd,z_{1}\downarrow z_{2},1)\vdash_{M^{\prime}}^{*}(q,\rhd\lhd,x\downarrow y,1),q_{f}\in F,q\in Q\}$. Further, this set is equal to $\{qx\downarrow y\mid(q,\rhd\lhd,x\downarrow y,1)\vdash_{M}^{*}(q_{f},\rhd\lhd,z_{1}\downarrow z_{2},1),q_{f}\in F,z\in\Gamma^{*}\}$, which must therefore be regular. \qed

By intersecting the two regular languages in the previous two lemmas, the following is obtained:

Proposition 31

Let $M$ be a two-way nondeterministic stack automaton such that $L(M)=\{\epsilon\}$. Then $S(M)$ is regular.

Proof 22

From Lemmas 29 and 30, and since regular languages are closed under intersection, $\{qx\downarrow y\mid(q_{0},\rhd\lhd,Z_{0}\downarrow,1)\vdash^{*}(q,\rhd\lhd,x\downarrow y,1)\vdash^{*}(q_{f},\rhd\lhd,z,1),q_{f}\in F,z\in\Gamma^{*}\}\in{\cal L}(\REG)$. \qed

From this, from Corollary 27, and since the regular languages are closed under homomorphism, the following is obtained:

Corollary 32

If $M$ is a two-way nondeterministic stack automaton such that $L(M)$ is finite, then $S(M)\in{\cal L}(\REG)$.

Corollary 33

If $M$ is a one-way nondeterministic stack automaton, then $S(M)\in{\cal L}(\REG)$.

Corollary 27 is also useful in other circumstances. For example, if a one-way machine model has store languages in some family ${\cal L}$ that is closed under homomorphism and ${\cal L}$ has a decidable emptiness problem, then the corresponding two-way model has its store language on a fixed word $w$ being in ${\cal L}$. By testing whether this store language is non-empty, this is determining whether $w$ is accepted by the two-way machine. Hence, membership is decidable for two-way machines. Therefore, for all one-way models studied here where the store languages are in ${\cal L}(\REG)$ or ${\cal L}(\NCM)$, membership in the corresponding two-way models is then decidable.

5 Applications to Right Quotient

There are some nice applications of the results in this paper. For example, it was shown in [5] that it is decidable whether the language accepted by a one-way reversal-bounded pushdown automaton is dense (the set of subwords is equal to $\Sigma^{*}$). Furthermore, this problem is also decidable for nondeterministic Turing machines with a one-way read-only input tape and a reversal-bounded worktape [30] (using Proposition 6 proven here). Also, certain applications to problems in the area of verification and model checking are presented in [6]. Another application is addressed here.

A general proof is exhibited whereby it is shown that any deterministic automata class ${\cal M}$ obtained from so-called “readable” store types, where the nondeterministic machines with the same store types only have regular store languages, then ${\cal L}({\cal M})$ is closed under right quotient with regular languages. This is perhaps surprising since right quotient seems to be quite difficult for deterministic machines.

Definition 34

Let $\Omega$ be a store type. Define $\Omega$ to be readable if the following are true:

• •

$\Omega$* has stay instructions.*

• •

At any point, if the store contains $y$ say, it is possible to switch to a configuration where the store can be read one letter at a time, either from left-to-right (like a queue), or right-to-left (like a pushdown).

The first condition is enforcing that it is possible to keep the same store contents. For example, with a pushdown automaton, it is always possible to replace the top of the pushdown $x$ with $x$, thereby keeping it the same. One could define a store type which is a pushdown with only push and pop instructions (the size of the stack is not allowed to stay the same), and such a store type would not be readable.

Proposition 35

Let $\Omega_{1},\ldots,\Omega_{k}$ be readable store types. Let ${\cal M}_{N}$ be the set of all one-way nondeterministic $(\Omega_{1},\ldots,\Omega_{k})$-machines, and let ${\cal M}_{D}$ be the set of all one-way deterministic $(\Omega_{1},\ldots,\Omega_{k})$-machines. If ${\cal S}({\cal M}_{N})\subseteq{\cal L}(\REG)$, then ${\cal L}({\cal M}_{D})$ is closed under right quotient with regular languages.

Proof 23

Let $M_{1}$ be a deterministic machine $M_{1}\in{\cal M}_{D}$ with state set $Q$. Let $M_{2}$ be a $\DFA$. A deterministic machine $M_{5}\in{\cal M}_{D}$ will be built accepting the right quotient of $L(M_{1})$ with $L(M_{2})$.

First, build a new intermediate nondeterministic machine $M_{3}\in{\cal M}_{N}$ with states $Q\cup Q^{\prime}\cup Q^{\prime\prime}$ with $Q,Q^{\prime},Q^{\prime\prime}$ being disjoint, and $Q^{\prime}$ being primed versions of states in $Q$ ($Q^{\prime\prime}$ described below). It accepts the following language:

[TABLE]

Intuitively, $M_{3}$ simulates $M_{1}$, and at some nondeterministically guessed spot, starts simulating $M_{2}$ in parallel using a second component simulating $M_{2}$ in the states. Specifically, at the nondeterministically guessed spot, if it’s in state $q$, it switches to state $q^{\prime}\in Q^{\prime}$, then to a state in $Q^{\prime\prime}$ (requiring the store contents to not change between these configurations, which is possible by the first condition of the readable store type definition), then $M_{3}$ continues the simulation only using states from $Q^{\prime\prime}$ (with two components, the second component simulating $M_{2}$). Certainly, $M_{3}$ is nondeterministic as it needs to guess where to start simulating $M_{2}$.

Next, construct the store language $S(M_{3})$. It is regular by the assumption. In fact, only words of $S(M_{3})$ that begin with $Q^{\prime}$ are needed. Consider $S(M_{3})\cap Q^{\prime}\Gamma^{*}$, and build a $\DFA$ $M_{4}$ accepting this set.

Now build a new deterministic machine $M_{5}\in{\cal M}_{D}$ that operates as follows. It simulates $M_{1}$ on the input $w$ until it hits the right input end-marker. At that point, say $y$ is the contents of the store, and it is in state $q$. First, assume that there is only one store which can be read from left-to-right (the store is readable). Then read $q^{\prime}$ in the store language $\DFA$ $M_{4}$ and see if $q^{\prime}y$ is in the store language deterministically on the store. If using a store that reads from right-to-left, instead use a $\DFA$ accepting $S(M_{4})^{R}$ instead of using $S(M_{4})$. Similarly, if using $k>1$ stores that are all readable (but the store language is still regular), then $M_{4}$ is constructed to reverse the subwords from stores read from right-to-left. In any of the cases, if $M_{4}$ accepts $q^{\prime}y$, then $M_{5}$ accepts the input.

Let $w\in L(M_{5})$. Then reading $w$ in $M_{5}$ (upon consuming the last letter) takes it to some configuration $qy$. Then $q^{\prime}y\in L(M_{4})$, and so $q^{\prime}y$ is in the store language of $M_{3}$, which means that the machine $M_{3}$ can accept from this configuration. And the fact that primed states are being used to enforce that it is at the right spot of the store language ensures that from that point on, the remaining word is in $L(M_{2})$. Thus, there must be some $x$ such that $wx$ is in $L(M_{1})$ and $x$ is in $L(M_{2})$.

Conversely, if $wx\in L(M_{1})$ with $x\in L(M_{2})$, then reading $w$ in $M_{1}$ takes it to some configuration $qy$. Then $q^{\prime}y$ must be in $L(M_{4})$. Hence, by the construction of $M_{5}$, $w\in L(M_{5})$.

Hence, ${\cal L}({\cal M}_{D})$ is closed under right quotient with regular languages. \qed

In the proof above, if the store languages of machines in ${\cal M}_{N}$ can be effectively constructed, then the machines accepting the right quotients can also be effectively constructed.

The following classes are readable, and hence the languages are closed under right quotient with regular languages: deterministic pushdown automata, deterministic one counter automata, deterministic $k$-flip pushdown automata, and deterministic reversal-bounded queue automata.

For deterministic stack automata, checking stack automata, and variants of $\DTM$s, they are not exactly readable, and the proof above does not completely apply, but can be adjusted. With e.g. stack automata, when $M_{5}$ reaches the end of the input, it could be in read mode; i.e. the store contents could be $\gamma=Z_{b}y_{1}\downarrow y_{2}Z^{t}$ where $y_{2}\neq\epsilon$. In this case, in order to read the stack contents from right-to-left (similarly with left-to-right) to verify that $\gamma$ is in $M_{4}$, the position of the read head is lost. (In other words, it is easy to verify that $Z_{b}y_{1}y_{2}\downarrow Z_{t}$ is in $L(M_{4})$, but not $\gamma$.) For deterministic Turing machines, it is possible to mark the position of the read/write head to make it verifiable. For stack automata, a slightly more complicated construction is needed. First make $M_{4}$ a complete $\DFA$ and adjust the stack alphabet to be ordered pairs, where the first component is an element from $\Gamma$, and the second component is a state in $M_{4}$. Whenever $M_{5}$ simulates the pushing of a symbol of $M_{1}$, $M_{5}$ pushes this as the first component, and for the second component, pushes the state of $M_{4}$ obtained from the state in the second component of the previous topmost symbol by reading the stack symbol pushed. Thus, if the stack contains $(b_{0},p_{0})\cdots(b_{m},p_{m})$, $b_{i}\in\Gamma,p_{i}$ is a state of $M_{4}$, then for all $i$, reading $b_{0}\cdots b_{i}$ in $M_{4}$ ends in state $p_{i}$. If a pop instruction occurs, then the state of $M_{4}$ is recoverable from the second component. At the end of the input, if $M_{5}$ is at the top of the stack, then the state in the second component immediately indicates whether the stack contents is in $L(M_{4})$. If $M_{5}$ is inside the stack with say $(b_{0},p_{0})(b_{1},p_{1})\cdots(b_{i},p_{m})\downarrow(b_{i+1},p_{i+1})\cdots(b_{m},p_{m})$ on the stack, then $M_{5}$ simulates $M_{4}$ starting from $p_{i}$, and verifies that from there, reading $\downarrow b_{i+1}\cdots b_{m}$ brings $M_{4}$ to a final state, thus verifying that its contents are in the store language. (Note that the state sequence $p_{i+1},\ldots,p_{m}$ was calculated without reading $\downarrow$ first, and therefore is different than reading $\downarrow b_{i+1}\cdots b_{m}$) Hence, it is possible to verify that $b_{0}\cdots b_{i}\downarrow b_{i+1}\cdots b_{m}\in L(M_{4})$. Therefore, the proof can be adjusted to work for stack automata and checking stack automata as well.

This implies closure under right quotient with regular languages for several families.

Corollary 36

The following language families are closed under right quotient with regular languages:

• •

deterministic stack languages **[17]**,

• •

deterministic checking stack languages,

• •

deterministic $k$-flip pushdown languages,

• •

deterministic pushdown automata **[19]**,

• •

deterministic one counter automata **[31]**,

• •

deterministic reversal-bounded queue automata,

• •

deterministic one-way read-only input Turing machines with a reversal-bounded worktape.

This does provide an alternate, much shorter and more general proof for stack and pushdown automata. It also resolves an explicitly stated unsolved open problem for $k$-flip pushdown automata [18]. All others are, to our knowledge, also unknown.

It is worth noticing the tight relationship between store languages and quotients. The intuition behind the closures under right quotient of all the families in Corollary 36 is that when the deterministic machines reach the end of their inputs, they can verify that their store contents are in the regular language constructed from the store language of a very similar nondeterministic machine. This same technique can even be true for non-regular store languages. For example, a similar technique could be used to show that $\DCM$ is closed under right quotient with $\NCM$. This is because when the $\DCM$ reaches the end of its input, it only needs to verify that its store contents are in another $\NCM$ language, and the store language of an $\NCM$ language is in $\DCM$. So it can do this in parallel with additional counters. However, in [31], a more general technique was used to show that $\DCM$ is closed under right quotient with even more general families such as $\NPDA$ and $\NPCM$.

Note as well that not all deterministic families are closed under right quotient with regular languages, as $\DPCM$ is not [31]. Indeed, the store of a $\DPCM$ is not necessarily in $\DPCM$, so when such a machine reaches the end of its input, there is not any way to verify that its store contents are “good” by using a store language within another $\DPCM$ machine.

6 Space Lower Bounds for Non-Regular Store Languages of Turing Machines

In this section, the lower bounds will be studied on the space complexity of $\NTM$s and $\DTM$s for the store language not to be regular. Here, $1\NTM$ ($1\DTM$) is used to denote a nondeterministic (deterministic) Turing machine with a one-way read-only input and a Turing tape, and $2\NTM$ ($2\DTM$) is used to denote a nondeterministic (deterministic) Turing machine with a two-way read-only input and a Turing tape.

A configuration of $M$ is a tuple $(q,\rhd w\lhd,x,i)$, where $q$ is a state, $w$ is the input with the input head on the $i$’th position, and the worktape contains string $x$ which includes the read/write head.

Let $M$ be any such Turing machine with either a one-way or two-way read-only input and one read/write worktape (i.e., store) tape. The following two notions of $M$ being $s(n)$ space-bounded are used (see [32]):

$M$ is strongly $s(n)$ space-bounded if, for any input $w$ of length $n$, all computations on $w$ (accepting or not) use at most $s(n)$ space on the worktape. 2. 2.

$M$ is middle $s(n)$ space-bounded if, for any input $w$ of length $n$ that is accepted, all accepting computations on $w$ use at most $s(n)$ space.

The following known results are needed:

Proposition 37

**

$\log\log n$* is the lower bound for accepting non-regular languages by strongly (middle respectively) space-bounded *$2\NTM$*s and $2\DTM$s. **[33, 34]**. * 2. 2.

$\log n$* is the lower bound for accepting non-regular languages by strongly (middle respectively) space-bounded *$1\NTM$*s and $1\DTM$s. **[33]**. *

In addition to the usual notion of the store language of space-bounded Turing machines, also the strong store language will be considered which is the set of reachable configurations; that is, if $M$ is a $2\NTM$ ($1\NTM$, $2\DTM$, $1\DTM$), the strong store language of M is $S^{s}(M)=\{qw\mid$ there is computation of $M$ (accepting or not) on some input of length $n$ that enters a configuration with state $q$ and $w$ on the worktape$\}$.

Proposition 38

If $M$ is a middle $s(n)$ space-bounded $2\NTM$ and $s(n)$ grows slower than $\log\log n$, then $S(M)$ is regular.

Proof 24

Construct a $2\NTM$ $M^{\prime}$ which, given an input $wqx$, where $w$ is over the input alphabet of $M$, $q$ is a state, and $x$ is over the worktape alphabet of $M$ (assume that the state set and alphabets are distinct) operates as follows:

$M^{\prime}$* simulates $M$ on $w$.* 2. 2.

At some point nondeterministically chosen, $M$ stops the simulation. Let the state and store contents of $M$ (and, hence, also of $M^{\prime}$) at that time be $q^{\prime}$ and $x^{\prime}$. $M^{\prime}$ converts $x^{\prime}$ to $q^{\prime}x^{\prime}\#q^{\prime}x^{\prime}$, where $\#$ is a new symbol. (Thus $M^{\prime}$ makes two copies of $q^{\prime}x^{\prime}$ separated by $\#$ with $x^{\prime}$ marking the position of the read/write head). 3. 3.

$M^{\prime}$* then resumes the simulation of $M$ using only the area to the right of $\#$ in the worktape.* 4. 4.

When $M$ accepts, $M^{\prime}$ checks that $qx$ on the input is identical to $q^{\prime}x^{\prime}$ on the worktape and accepts.

Clearly $M^{\prime}$ is also $s(n)$ space-bounded, hence $L(M^{\prime})$ is regular by Proposition 37, part 1. Now, the strings in $L(M^{\prime})$ are of the form $wqx$. A homomorphism deleting $w$ is then applied. It follows that the strong store language is regular. \qed

Furthermore, given a Turing machine $M$ that is strongly $s(n)$ space-bounded, one can build $M^{\prime}$ exactly like $M$ but with all states final, and $M^{\prime}$ is middle $s(n)$ space-bounded and $S^{s}(M)=S(M^{\prime})$. Therefore:

Corollary 39

If $M$ is a strongly $s(n)$ space-bounded $2\NTM$ and $s(n)$ grows slower than $\log\log n$, then $S^{s}(M)$ is regular.

Next, it will be shown that the $\log\log n$ bound above is tight.

Proposition 40

There is a strongly $\log\log n$ space-bounded $2\DTM$ $M$ such that $S^{s}(M)$ is not regular.

Proof 25

Let $L=\{x_{1}\#x_{2}\#\cdots\#x_{k}\#~{}|~{}k\geq 1,x_{i}\in 1\{0,1\}^{*},x_{1}=1,x_{i+1}=x_{i}+1\mbox{~{}for~{}}1\leq i<k,x_{k}=1^{m}\mbox{~{}for some~{}}m\}$. The addition is binary number addition. So, e.g., $1\#10\#\ 11\#100\#101\#110\#111\#$ is in $L$. Construct a $2\DTM$ $M$ which, when given a string $w=x_{1}\#x_{2}\#\cdots\#x_{k}\#$, verifies that $x_{1}=1,x_{k}=1^{m}$ for some $m\geq 1$, each $x_{i}$ starts with $1$, and also verifies that each $x_{i}+1=x_{i+1}$. To do the latter, $M$ uses the worktape to keep a binary counter referring to a bit position of each string $x_{i}$. The counter starts at $1$, then it compares the last bit of $x_{i}$ to $x_{i+1}$, then it increases the counter by $1$, and compares the second last bit of $x_{i}$ to $x_{i+1}$, etc. It is clear that this counter can grow as the large as the length of the longest $x_{i}$. As the counter is in binary, this requires approximately $\log|x_{i}|$ bits of space. When $M$ determines that $w$ is in $L$, the worktape will have $m$ on its worktape in binary; call this string $b(m)$. $M$ then transforms $b(m)$ to $b(m)\#b(m)$ and enters state $f$. Then $S^{s}(M)\cap f\{0,1\}^{+}\#\{0,1\}^{+}=\{fw\#w~{}|~{}w\in 1\{0,1\}^{*}\}$, which is not regular. Hence $S^{s}(M)$ is not regular.

Clearly, on input longer than $k$, $|x_{k}|$ is approximately $\log k$, and the worktape is approximately the size of $\log|x_{k}|$. Thus, $M$ is strongly $\log\log n$ space-bounded. \qed

Hence, the following is immediate:

Corollary 41

There is a middle $\log\log n$ space-bounded $2\DTM$ $M$ such that $S(M)$ is not regular.

Turning now to one-way machines:

Proposition 42

If $M$ is a middle $s(n)$ space-bounded $1\NTM$ and $s(n)$ grows slower than $\log n$, then $S(M)$ is regular.

Proof 26

The proof is the same as the proof of Proposition 38 using Proposition 37, part 2, and noting that the $M^{\prime}$ constructed in that proof would also be one-way if $M$ is one-way. \qed

Corollary 43

If $M$ is a strongly $s(n)$ space-bounded $1\NTM$ and $s(n)$ grows slower than $\log n$, then $S^{s}(M)$ is regular.

The next result shows that Proposition 42 is tight.

Proposition 44

There is a strongly $\log n$ space-bounded $1\DTM$ $M$ such that $S^{s}(M)$ and $S(M)$ are not regular.

Proof 27

Let $L=\{a^{n}b^{n}~{}|~{}n\geq 1\}$. Construct a strongly $\log n$ space-bounded $1\DTM$ to accept $L$. $M$ when given an input $a^{n}b^{m}$, first reads $a^{n}$ and stores $n$ in binary, say $x$, on the worktape. Then $M$ converts $x$ to $x\#x$. Next, $M$ reads $b^{m}$ while decrementing the second $x$ on the worktape to check that $m=n$. Finally, $M^{\prime}$ converts the worktape to $x\#x$ and accepts in state $f$. Clearly, $S^{s}(M)\cap f(0+1)^{+}\#(0+1)^{+}=\{fx\#x~{}|~{}x\in 1\{0,1\}^{*}\}$ is not regular. Hence, $S^{s}(M)$ is not regular. Making all states final then gives the same result for $S(M)$. \qed

Corollary 45

There is a middle $\log n$ space-bounded $1\DTM$ $M$ such that $S(M)$ is not regular.

7 Conclusions and Future Directions

Store languages are studied in a general fashion, by varying the types of stores used. Certain specific models are studied such as nondeterministic Turing machines with a one-way read-only input tape and a reversal-bounded read/write worktape, and it is shown that all store languages are regular. Similarly, all store languages of $k$-flip pushdown automata are regular. Then it is shown that store languages of one-way nondeterministic, and one-way deterministic machines coincide, when using the same store types. Similarly, these coincide with two-way machines that accept finite languages over the same store types after applying a homomorphism. One application of store languages is presented here. If there is a one-way nondeterministic model with readable store types that only has regular store languages, then the languages accepted by deterministic machines with the same store types are closed under right quotient with regular languages. This resolves several open problems in the literature. This type of result is only possible by studying store languages in the general fashion done here. Lastly, space-bounded Turing machines are studied, and lower bounds are given to have non-regular store languages.

There are many other machine models in the literature that have yet to have their store language studied. The store languages of $\NPCM$ will be considered in a follow-up paper. Also, the pushdown hierarchy is of interest [35]. We also believe that there are many other applications of store languages, similar to the result on right quotient studied here.

Acknowledgements

We thank the reviewers for their comments that improved the presentation of our results.