A Linear-time Simulation of Deterministic $d$-Limited Automata

We next recall the notion of $d$-limited automata, introduced by Hibbard [8]. A $d$-limited automaton ($d$-LA) is a nondeterministic Turing machine that scans only the cells containing the input word together with end-markers, and is allowed to rewrite a symbol in each cell (except the end-markers) only during its first $d$ visits. Hibbard showed that for every $d\geqslant 2$ $d$-LAs recognize precisely the class of context-free languages; it is also known that $1$-LAs recognize exactly the class of regular languages [21]. For $d=\infty$, the model coincides with linear-bounded automata, which recognize the class of context-sensitive languages.

For the deterministic case, Pighizzini and Pisoni [14] proved that deterministic $2$-LAs recognize exactly the deterministic context-free languages (DCFLs) by providing an algorithm that transforms a 2-LA into a PDA while preserving determinism; the inverse transformation had already been established by Hibbard [8]. Following Hibbard, we call a language recognized by a deterministic $d$-LA a $d$-deterministic language ($d$-DCFL) and denote such automata by $d$-DLAs. Hibbard also established that the hierarchy is strict: for every fixed $d$, the class of $(d\!+\!1)$-DCFLs properly contains the class of $d$-DCFLs.

Although DCFLs are widely used, they suffer from certain practical limitations. First, they are not closed under reversal: while both

are DCFLs, their union is a DCFL, but the reversal $(L_{d}\cup L_{e})^{R}$ is not. This language can still be recognized by a $3$-DLA, which can scan the input from right to left before simulating a $2$-DLA for $L_{d}\cup L_{e}$.

Second, DCFLs are not closed under union. The language

is a union of two DCFLs but is known to be inherently ambiguous [17]. Every DCFL can be generated by an unambiguous grammar, in particular by an ${\mathrm{LR}}(1)$ grammar, and Hibbard showed [8] that the same holds for $d$-DCFLs. Hence the union $\bigcup_{d\geqslant 1}d$-DCFLs does not cover all CFLs. This illustrates that $d$-DCFLs, like DCFLs, are not closed under union; recognizing such languages in linear time via $d$-DLAs requires parallelism.

We now consider a natural extension of $d$-LAs. Assume that $d$ is not a constant but a function $d(n)$ depending on the input length $n$. The automaton can then rewrite the content of a cell until the number of visits to that cell reaches $d(n)$. To our knowledge, this is the first time such a generalization has been considered. In classical restrictions on Turing machine computation, the time bound is imposed on the total number of cell visits, whereas here we impose a bound on the number of visits per individual cell (after which the cell remains accessible for reading but no longer for rewriting).

We focus on the membership problem for $d(n)$-DLAs. Let $m$ be the length of the description of a $d(n)$-DLA ${\cal A}$, $k$ the number of its states, and $n$ the length of the input word $w$. We present an $O(n\cdot k\cdot d(n)+m)$ algorithm in the RAM model for the membership problem. In particular, when ${\cal A}$ is fixed and $d(n)=O(1)$ (i.e., for $d$-DLAs), this yields a linear-time algorithm. Thus every $d$-DCFL is recognizable in linear time in the RAM model.

Hennie proved in [7] that every language recognizable in linear time by a deterministic Turing machine is regular (and a more general result holds for nondeterministic TMs [19, 13]). Hence no $d$-DLA with $d\geqslant 2$ can be simulated by a linear-time Turing machine. Guillon and Prigioniero [6] showed that every $1$-DLA can be transformed into an equivalent linear-time Turing machine (and an analogous result holds for nondeterministic $1$-LAs), and a related construction was also used by Kutrib and Wendlandt [11]. Their approach relies on Shepherdson’s classical simulation of two-way DFAs by one-way DFAs [18]. We build on this idea as well, but it cannot be applied directly because of Hennie’s result: otherwise one could simulate a non-regular language in linear time on a Turing machine, contradicting the theorem.

To overcome this obstacle we transform a classical Turing machine into one that operates on a doubly-linked list instead of a tape and adapt Shepherdson’s construction to this model. This forms the basis of our membership algorithm. We also reinterpret Birget’s algebraic constructions [3] in graph-theoretic terms, which provides subroutines underlying the final version of our algorithm. A related algebraic approach was developed by Kunc and Okhotin [10], who employed transformation semigroups to capture, for each substring, the state-to-state behavior of two-way deterministic finite automata. This line of work closely mirrors Birget’s method via function composition, and our construction follows the same underlying ideas.

We further establish an upper bound of $O(d(n)\cdot n^{2})$ steps for direct simulation of $d(n)$-DLAs, provided the computation does not enter an infinite loop. In particular, this implies an $O(n^{2})$ upper bound for $d$-DLAs, which, to the best of our knowledge, was previously open. This bound is tight: it is witnessed by the classical $d$-DLA recognizing the language $\{a^{n}b^{n}\mid n\geqslant 0\}$.

From a theoretical perspective, our results show that some CFLs are easy (linear-time recognizable), while in general recognition of CFLs may require $O(n^{\omega})$ time, and by conditional results there must exist hard CFLs (recognizable only in superlinear time). We discuss this point in the following subsection.

We begin with linear-time recognizable subclasses of context-sensitive languages (CSLs) and context-free languages (CFLs). E. Bertsch and M.-J. Nederhof [2] showed that a nontrivial subclass of CFLs, the regular closure of DCFLs, is recognizable in linear time. This class consists of all languages obtained by taking a regular expression and replacing each symbol with a DCFL. It evidently contains the aforementioned language $L_{d,e}$ (as a union of DCFLs), so it is a strict extension of DCFLs. Note also that $L_{d,e}$ is recognizable by 2-DPDAs.

A broad subclass of CSLs recognizable in linear time is given by the class of languages accepted by two-way deterministic pushdown automata (2-DPDAs). A linear-time simulation algorithm for 2-DPDAs was obtained by S. Cook [4]. This class clearly contains DCFLs, and it also includes the language of palindromes over an alphabet of at least two letters, which is a well-known example of a context-free language that is not a DCFL.

A. Rubtsov and N. Chudinov introduced in [15, 16] a computational model, DPPDA, for Parsing Expression Grammars (PEGs). This model extends DCFLs, remains recognizable in linear time, and is based on a modification of classical pushdown storage. It was also shown that the class of languages recognized by 2-DPPDAs is recognizable in linear time. Moreover, they proved that parsing expression languages (the class generated by PEGs) contain a highly nontrivial subclass, namely the Boolean closure of the regular closure of DCFLs.

It remains open whether 2-DPDAs, 2-DPPDAs, or PEGs recognize all CFLs. However, the works of L. Lee [12] and Abboud et al. [1] provide strong evidence that this is very unlikely due to complexity-theoretic considerations: any CFG parser with time complexity $O(gn^{3-\varepsilon})$, where $g$ is the size of the grammar and $n$ the input length, can be efficiently converted into an algorithm for multiplying $m\times m$ Boolean matrices in time $O(m^{3-\varepsilon/3})$. This naturally raises the question: can 2-DPDAs or 2-DPPDAs simulate $d$-DLAs for $d\geqslant 3$?

Finally, T. Yamakami presented another extension of Hibbard’s approach [22, 23]: in several models the input tape is one-way read-only, while the work tape obeys a similar restriction, forbidding rewriting beyond the first $d$ visits. We leave the application of our simulation technique to such models as a direction for future research.

Let $d\geqslant 0$ be a fixed integer. A deterministic $d$-limited automaton ($d$-DLA) is a deterministic single-tape Turing machine whose tape initially contains the input word bordered by the left endmarker $\vartriangleright$ and the right endmarker $\vartriangleleft$. Each tape symbol is annotated with an integer in $\{0,\dots,d\}$, called its rank. Initially, all letters of the input word have rank $0$, while the endmarkers have rank $d$. Whenever the head visits a cell containing a symbol of rank $r<d$, the symbol may be overwritten with a new symbol of rank $r^{\prime}$ such that $r<r^{\prime}\leqslant d$. Symbols of rank $d$ are read-only and cannot be changed.

Formally, a $d$-DLA ${\cal A}$ is defined by a tuple

where $Q$ is a finite set of states, $\Sigma$ is the input alphabet (symbols of rank $0$), $\Gamma$ is the tape alphabet with $\Sigma\cup\{\vartriangleright,\vartriangleleft\}\subseteq\Gamma$, for each $r$ we let $\Gamma_{r}\subseteq\Gamma$ denote the set of symbols of rank $r$, $q_{0}\in Q$ is the initial state, $F\subseteq Q$ is the set of accepting states, and $\delta$ is the transition function

such that:

• •

  for $a_{r}\in\Gamma_{r}$ with $r<d$, each transition is of the form

  $$\delta(q,a_{r})=(q^{\prime},a_{r^{\prime}},m),$$

  where $a_{r^{\prime}}\in\Gamma_{r^{\prime}}\setminus\{\vartriangleright,\vartriangleleft\}$, $r<r^{\prime}\leqslant d$, and $m\in\{\leftarrow,\rightarrow\}$;

• •

  for $a_{d}\in\Gamma_{d}$, each transition is of the form

  $$\delta(q,a_{d})=(q^{\prime},a_{d},m),$$

  where $m\in\{\leftarrow,\rightarrow\}$; moreover, if $a_{d}=\vartriangleright$ then $m=\rightarrow$, and if $a_{d}=\vartriangleleft$ then $m=\leftarrow$.

A $d$-DLA starts in state $q_{0}$ with the head positioned on the first input symbol (immediately to the right of the left endmarker $\vartriangleright$). At each step, given a state $q$ and the symbol $a$ under the head, it computes $\delta(q,a)=(q^{\prime},a^{\prime},m)$, replaces $a$ with $a^{\prime}$, updates its state to $q^{\prime}$, and moves the head left or right according to $m$. The input is accepted if the automaton reaches a state $q_{f}\in F$ while scanning the right endmarker $\vartriangleleft$; in this case the computation halts.

We slightly modify Hibbard’s original definition by requiring the transition function to be total. This modification does not change the class of recognizable languages and comes at the cost of a single additional state.

We next introduce an auxiliary model, which we call the Deterministic Linked-List Automaton (DLLA). In this model there is no constraint on the number of visits to a cell. The tape is replaced by a doubly linked list, so the automaton may delete any cell between the endmarkers (but never the endmarkers themselves). Formally, a DLLA has the same components as a $d$-DLA (states, input and tape alphabets, initial and accepting states), but with a modified transition function:

where the special symbol $\perp$ indicates that the current cell is to be deleted immediately after the head leaves it. Once a cell is deleted, the head moves directly from its left neighbor to its right neighbor when moving right, and symmetrically when moving left. If the transition function returns $\uparrow$, the computation halts and the input is rejected. No additional restrictions are imposed on the transition function.

It is easy to see that DLLAs recognize exactly the class of deterministic context-sensitive languages. They can simulate deterministic linear-bounded automata (DLBA) directly, and conversely, a DLBA can simulate a DLLA by marking a deleted cell with a special symbol. We employ the doubly linked list representation in order to achieve the claimed upper bounds for deterministic $d(n)$-DLAs.

For $d$-DLAs it is convenient to associate with each letter $a_{r}$ its rank $r$, representing the number of visits to the corresponding cell. For $d(n)$-DLAs this is no longer possible, since the alphabet and the machine description are fixed and cannot grow with the input length. Instead, in a $d(n)$-DLA each tape cell maintains its own visit counter, so the rank is associated with the cell rather than the symbol. Formally, each cell (except the endmarkers $\vartriangleright,\vartriangleleft$) contains a pair $(a,e)$, where $a\in\Gamma$ and $e$ is a bit. The bit $e$ is initially $0$, and remains $0$ while the number of visits to the cell is less than $d(n)$; once the number of visits reaches $d(n)$, $e$ is set to $1$, and from that point on the cell becomes read-only.

This modification of $d$-DLAs does not affect our simulation algorithm. The value of $d(n)$ is fixed for a given input length $n$, and the algorithm never relies on $d$ being a constant rather than a precomputed parameter. Therefore, it suffices to describe the simulation algorithm for $d$-DLAs; the extension to $d(n)$-DLAs is straightforward.

We now present a high-level simulation algorithm for the recognition problem. Detailed constructions of the subroutines will be given later in Subsection 3.3, where the membership problem is analyzed. The algorithm below both formally defines the DLLA $M$ that simulates ${\cal A}$, and at the same time serves as the procedure for simulating $M$ on a RAM model.

Simulation Algorithm 1 is given in pseudocode; its description in natural language is as follows. Since the DLLA $M$ deletes cells during its run, we refer to the current left and right neighbors of the $i$-th cell as $i.\mathsf{prev}$ and $i.\mathsf{next}$, respectively. When we write $j=i.\mathsf{prev}$ we assume that both $i$ and $j$ refer to the indices of ${\cal A}$’s tape cells; we do not reenumerate the cells of $M$’s tape.

Thus, we denote the $i$-th cell of $M$’s tape by $W_{M}[i]$. If $W_{\cal A}[i]$ contains a letter of rank less than $d-1$, then $W_{M}[i]=W_{\cal A}[i]$, and $M$ behaves exactly as ${\cal A}$ (an ${\cal A}$-move). When $M$ visits a cell for the $d$-th time, where ${\cal A}$ would write a symbol $X$ of rank $d$ (not an end-marker), $M$ instead writes to that cell a mapping $g=CF(X)$. When $M$ writes a mapping $g$ in a cell $i$ for the first time, it scans the neighbors $i.\mathsf{prev}$ and $i.\mathsf{next}$ and performs the procedure we call a deletion scan.

• •

  If none of the neighbors contains a mapping, the scan is finished.

• •

  If only one of the neighbors $i.\mathsf{prev}$ or $i.\mathsf{next}$ contains a mapping (say $f$ or $h$), then $M$ replaces $i$ with $f\diamond g$ (or $g\diamond h$) and deletes the neighboring cell.

• •

  If both neighbors contain mappings, then $M$ replaces $i$ with $f\diamond g\diamond h$ and deletes both neighboring cells.

After a deletion scan the cell $W_{M}[i]$ contains the resulting mapping, say $g$, while both its neighbors contain letters. Hence $g$ describes the segment $W_{\cal A}[i.\mathsf{prev}+1,\,i.\mathsf{next}]$. $M$ then moves the head to the same neighbor ($i.\mathsf{prev}$ or $i.\mathsf{next}$) where ${\cal A}$ would be after leaving the rank-$d$ segment $W_{\cal A}[i.\mathsf{prev}+1,\,i.\mathsf{next}]$. If the head of ${\cal A}$ had not quit the segment $W_{\cal A}[i.\mathsf{prev}+1,\,i.\mathsf{next}]$ right after visiting $W_{\cal A}[i]$, the cell where ${\cal A}$ arrives after it exits the segment is determined via the departure function $D$ during the deletion scan.

We have thus described the cases in which $M$ arrives:

• •

  at a cell of rank $r<d$ (from any neighbor), and

• •

  at a cell of rank $d$ (from another rank-$d$ cell).

It remains to describe the case when $M$ arrives at a cell containing a mapping $f$ in a directed state $\overleftrightarrow{q}$, coming from a cell with a letter of rank $r<d$ (lines 1–1). In this case $M$ computes $f(\overleftrightarrow{q})=\overleftrightarrow{p}$ and moves the head to the left or right neighbor according to the direction of $\overleftrightarrow{p}$, arriving at that neighbor in state $p$.

Before proving correctness we fix notation for time indices. Let $W_{\cal A}^{t}[i]$ denote the content of cell $i$ of ${\cal A}$’s tape after $t$ steps of ${\cal A}$, and let $W_{M}^{t^{\prime}}[i]$ denote the content of cell $i$ of $M$’s tape after $t^{\prime}$ steps of $M$. We consider only regular steps, i.e. steps performed on symbols of rank $<d$ or on endmarkers. Every regular step $t$ of ${\cal A}$ has a corresponding regular step $t^{\prime}$ of $M$, and the mapping $t\mapsto t^{\prime}$ is strictly increasing (if $t_{1}<t_{2}$ then $t^{\prime}_{1}<t^{\prime}_{2}$). This correspondence will be used below.

Now we prove that the simulation algorithm for $d$-DLAs works in linear time. We present the proof for the general case of a $d(n)$-DLA. The simulation algorithm for $d(n)$-DLAs is identical to that for a fixed $d$, since its behavior depends only on whether the number of visits to a cell is equal to $d(n)-1$ or smaller. The counters for cell visits required in the case of $d(n)$-DLAs can be implemented in the RAM model with $O(1)$ overhead per operation, and thus do not affect the asymptotic running time.

We denote by $\langle F\rangle({\cal A})$ the time complexity of the operation $F$ on a $d$-DLA ${\cal A}$. Since we will prove later that the complexity of each auxiliary step depending on ${\cal A}$ is $O(|Q|)$, we replace $\langle CF\rangle({\cal A})$, $\langle D\rangle({\cal A})$, and $\langle\diamond\rangle({\cal A})$ by

To analyze the membership problem for $d$-DLAs we need to formalize the auxiliary operations on mappings. Recall that mappings represent contiguous segments of rank-$d$ cells and that the simulation algorithm relies on three basic subroutines:

• •

  the cell description function $CF$, which produces the mapping for a single rank-$d$ cell;

• •

  the directed composition $\diamond$, which merges mappings of adjacent segments into one;

• •

  the departure function $D$, which determines the exit state and direction when the head is located at the boundary between two adjacent segments, i.e., when it enters one segment from the other.

We prove in this subsection that all these operations are well-defined and computable in $O(|Q_{\cal A}|)$ time, so $\langle U\!B\rangle({\cal A})=O(|Q_{\cal A}|)$.

Our constructions rely on graph representations of mappings. A mapping $f\in{\cal F}$ describing a segment $L$ is encoded by a four-partite graph $G_{f}$ with parts $\overrightarrow{L}_{\mathsf{in}},\overleftarrow{L}_{\mathsf{in}},\overrightarrow{L}_{\mathsf{out}},\overleftarrow{L}_{\mathsf{out}}$, each a copy of $Q_{\cal A}$. These four parts form a partition of the set $\overleftrightarrow{Q}$ according to their labeling. We also adjoin a distinguished sink vertex $(\uparrow)$ of out-degree $0$. For every $\overleftrightarrow{q}\in\overleftrightarrow{L}_{\mathsf{in}}$ we add:

• •

  an edge $\overleftrightarrow{q}\to\overleftrightarrow{p}$ to some $\overleftrightarrow{p}\in\overleftrightarrow{L}_{\mathsf{out}}$ if $f(\overleftrightarrow{q})=\overleftrightarrow{p}$,

• •

  or an edge $\overleftrightarrow{q}\to(\uparrow)$ if $f(\overleftrightarrow{q})=\uparrow$.

Thus every vertex has out-degree at most $1$: inputs have either one outgoing edge to an output or to $(\uparrow)$, while outputs and $(\uparrow)$ have out-degree $0$. We say that $G_{f}$ represents the mapping $f$ (or the segment $L$).

If $g$ describes an adjacent segment $R$, to compute the composition $f\diamond g$ and the departure function $D$ we use the intermediate graph ${\cal I}(f,g)$ obtained by gluing the graphs $G_{f}$ and $G_{g}$ (with parts labeled by $R$). Formally, ${\cal I}(f,g)$ is defined as follows: part $\overrightarrow{L}_{\mathsf{out}}$ is glued with $\overrightarrow{R}_{\mathsf{in}}$, part $\overleftarrow{L}_{\mathsf{in}}$ with $\overleftarrow{R}_{\mathsf{out}}$, and the two sinks $(\uparrow)$ are glued together. By gluing two vertices we mean that one of them is deleted and all its edges are reattached to the other. When we glue parts, we glue the vertices carrying the same state label (but with opposite directions). An illustration of ${\cal I}(f,g)$ is given in Fig. 1.

We now summarize the simulation in the following theorem.