Sweep Complexity Revisited^††thanks: This work was supported by JSPS KAKENHI Grant Number JP23K10976.

In roughly the last three decades, several non-classical models of automata have been introduced to study the effect of processing inputs with simple machines in a non-sequential way. Such models include restarting automata [10], jumping automata [12], input revolving automata [4] and automata with translucent letters [13]. However, these models are either strictly more powerful or accept a class incomparable with the regular one.

One-way jumping finite automata (OWJFA) were introduced [5] to study the power of deterministic finite automata (DFA) performing non-sequential processing without completely discarding structural information about the inputs à la jumping automata. The resulting model is, in a sense, a minimal extension of finite automata. Machines are specified in exactly the same way as DFA allowing partial transition functions. The only change is the behaviour of the machine when encountering a letter for which the current state has no outgoing transition defined. In the classical case such inputs are rejected, but in one-way jumping mode the letters are skipped temporarily to be processed later. The relative order of the skipped symbols is maintained, and the automaton moves back to the beginning after each pass (called sweep here), seeing only the symbols previously skipped. Therefore one can also view this model as a DFA with an input tape which works as a restricted queue, or one that reads and erases symbols from a circular tape always jumping clockwise to the nearest letter for which it has a defined transition from the current state. When the transition function is complete, no symbols are skipped, so the machine behaves as ordinary DFA, which means that the class of languages accepted by DFA in one-way jumping mode trivially includes all regular languages.

Various properties of the accepted language class [1] and the status of fundamental decidability questions have been settled [2]. More powerful machines with this new processing mode have also been investigated, such as nondeterministic finite automata [3, 6], two-way finite automata [7], pushdown automata and linear bounded automata [6]. While the language classes defined by the models have no nontrivial closure properties under usual language operations, the accepting power and decidability issues raised some intriguing problems.

Except for linear bounded automata, the machine models mentioned above become more powerful when they are allowed to jump to the nearest symbol readable in the current state, which is not surprising. However, it has proven challenging to get a clear picture of just how powerful the new processing mode is, even in the simplest case when one starts from DFA. Such automata can accept all regular languages and the language class defined by them is incomparable with the context-free class, but included in the context-sensitive class and in DTIME($n^{2}$) [1]. The separation results make use of combinations of a handful of regular languages together with a very simple type of non-regular languages which contain words having letter counts in a certain ratio, e.g., the frequently used $L_{ab}=\{w\in\{a,b\}^{*}\mid w\textrm{ contains as many }a\textrm{'s as }b\textrm{'s}\}$ accepted by the machine $\mathcal{A}$ in Fig 2 (with states $\mathbf{1}$, or $\mathbf{2}$ final). While this was enough to establish virtually all separations of interest, it left a significant gap in our understanding of the model: can such machines accept any (‘interesting’) non-regular languages apart from the ones which establish linear relationships among letter counts?

In this work we answer the question above, building on the investigation of sweep complexity of DFA in one-way jumping mode. Sweep count can be viewed as a measure of non-regular resources used by a machine posing the natural question of how much of this resource is needed to be able to accept non-regular languages? It has been shown that constant sweep complexity does not increase the accepting power of the machines [9] and that superconstant sweep complexity requires cycles containing ‘complementary deficient’ states [8]. In the latter paper it was conjectured that, in fact, any automaton with higher than constant sweep complexity accepts a non-regular language. In Section 3 we refute that conjecture by exhibiting a small DFA accepting a regular language while processing some inputs of length $n$ in $\Omega(\log n)$ sweeps. We also show that there is no non-trivial upper bound on the sweep complexity of regular languages, that is, there are machines with linear complexity accepting regular languages.

A natural question regarding the new complexity measure is whether there exists a meaningful hierarchy which does not collapse to the extremes of $\mathcal{O}(1)$ and $\mathcal{O}(n)$. The aforementioned example shows that automata with logarithmic complexity exist, which answers another question posed earlier. Furthermore, following the line of computational complexity theory, we set out to explore whether the language classes defined through asymptotic complexity form a true hierarchy, that is whether there are languages which can be accepted by a machine with $\mathcal{O}(f(n))$ complexity but not by any with $o(f(n))$ complexity, for various functions $f(n)$. In Section 4 we demonstrate that such a hierarchy exists by presenting languages with $\Theta(\log n)$ and $\Theta(n)$ sweep complexity, respectively.

Finally we mention that sweep complexity as an idea has been studied in other contexts, too: an interesting and thorough investigation of a similar flavor established infinite hierarchies in terms of sweep count for iterated uniform finite transducers [11], although that model is significantly more powerful than ours, so the techniques used there do not translate here as far as we can tell.

We consider words over a finite alphabet, e.g., $\Sigma=\{a,b\}$. The set of all words over $\Sigma$ is $\Sigma^{*}$, which includes the empty word $\varepsilon$.

A DFA is a quintuple $M=(Q,\Sigma,R,\textbf{s},F)$, where $Q$ is the finite set of states, $\Sigma$ is the finite input alphabet, $\Sigma\cap Q=\emptyset$, $R:Q\times\Sigma\rightarrow Q$ is the transition function, $\textbf{s}\in Q$ is the start state, and $F\subseteq Q$ is the set of final states. Elements of $R$ are referred to as (transition) rules of $M$ and we write $\textbf{p}y\rightarrow\textbf{q}\in R$ instead of $R(\textbf{p},y)=\textbf{q}$. A configuration of $M$ is a string in $Q\times\Sigma^{*}$.

A DFA transitions from a configuration $\textbf{p}w$ to a configuration $\textbf{q}w^{\prime}$ if $w=aw^{\prime}$ and $\textbf{p}a\rightarrow\textbf{q}\in R$, with $\textbf{p},\textbf{q}\in Q$, $w,w^{\prime}\in\Sigma^{*}$ and $a\in\Sigma$. By extending the meaning of $\rightarrow$ we denote this by $\textbf{p}w\rightarrow\textbf{q}w^{\prime}$ and the reflexive and transitive closure of $\rightarrow$ by $\rightarrow^{*}$. A word $w$ is accepted by a DFA $M$ if there exists $\textbf{f}\in F$, such that $\textbf{s}w\rightarrow^{*}\textbf{f}$. The language accepted by $M$ is $\{w\in\Sigma^{*}\mid\exists\textbf{f}\in F:\textbf{s}w\rightarrow^{*}\textbf{f}\}$.

A tuple $M=(Q,\Sigma,R,\textbf{s},F)$ representing a deterministic right one-way jumping automaton (ROWJFA) is defined the same way as a DFA, where the configurations are also elements of the set $Q\times\Sigma^{*}$. Let $\Sigma_{p}=\{b\in\Sigma\mid\exists\textbf{q}\in Q$ such that $\textbf{p}b\rightarrow\textbf{q}\in R\}$ be the set of all of the letters from $\Sigma$ for which we have a transition defined from state p. A jumping transition (or jump, for short), denoted $\circlearrowright$, is defined between configurations $\textbf{p}ax$ and $\textbf{p}xa$ if state p cannot read the letter $a$, formally:

A ROWJFA can transition from configuration $\textbf{p}ax$ to configuration $\textbf{q}y$, which we denote by $\textbf{p}ax\vdash\textbf{q}y$, if

A word $w$ is accepted by $M$ if $\textbf{s}w\vdash^{*}\textbf{f}$. The language accepted by $M$ is defined by $L(M)=\{x\in\Sigma^{*}\mid\exists\textbf{f}\in F:\textbf{s}x\vdash^{*}\textbf{f}\}.$

While some texts define DFA having complete transition functions, our DFA allow partially defined ones. Indeed, the pairs $(\textbf{p},a)\in Q\times\Sigma$ for which no transition is defined enable the ROWJFA to perform a jump as opposed to rejecting the input as a DFA would. Hence, a ROWJFA with a complete transition function is just a DFA.

Sweeps are contiguous sequences of transitions on a given input, consisting of the steps from reading or jumping over the leftmost remaining input letter to reading or jumping over the rightmost one. If a position is jumped over, then the input symbol in that position is processed in a later sweep. The number of sweeps needed to process the whole input is the number of times the automaton reaches the last position of the original input word or, equivalently, one more than the maximum number of times any position is jumped over.

For an intuitive picture of sweeps, consider the computation of a ROWJFA $M$ on input $w$ as a table with rows representing the $k$ sweeps needed to process $w$ and columns representing positions in the input word. Cell $i,j$ in the table contains either a letter or a symbol representing that the letter has been read, e.g., $\varepsilon$. Once a letter has been marked read and erased it stays that way, so each column is a word of the form $a^{\ell}\varepsilon^{k-\ell}$ ($=a^{\ell}$) for some $a\in\Sigma$ and $1\leq\ell\leq k$.

In order to be able to analyze the boundary between regular and non-regular languages accepted by the one-way jumping model, as well as to quantify the use of resources beyond the capabilities of classical DFA, when it is the case, the following complexity measure was proposed [8], which gives us the number of sweeps performed by a machine in the ‘worst case’ for an input of length $n$.

Let $M$ be a ROWJFA and $w\in L(M)$, and let

be the computation of $M$ on the input $w$. Sweep $1$ consists of $\mathbf{p}_{0}w\vdash^{*}\mathbf{p}_{|w|}w_{|w|}$, and we say that sweep $1$ ends in configuration $\mathbf{p}_{|w|}w_{|w|}$. Then, for all $i\geq 1$, if sweep $i$ ends in configuration $\mathbf{p}_{s_{i}}w_{s_{i}}$, then sweep $i+1$ is the sequence of configurations $\mathbf{p}_{s_{i}}w_{s_{i}}\vdash^{*}\mathbf{p}_{s_{i}+|w_{s_{i}}|}w_{s_{i}+|w_{s_{i}}|}$. The last sweep ends in configuration $\mathbf{p}_{m}$, that is, when all input symbols have been read. We define

When $w\notin L(M)$, then we set $E(M,w)=0$. The sweep complexity of a machine $M$ is a function $sc_{M}:\mathbb{N}\rightarrow\mathbb{N}$, with $sc_{M}(n)$ being the maximum number of sweeps $M$ makes on processing inputs $w\in L(M)$ of length $n$, formally:

In a sense the “most non-regular” word (using the largest amount of non-classical resources) of each length is considered. With this in mind, we can define complexity classes in the usual manner: the class $\mathrm{SWEEP}(f(n))$ consists of languages accepted by some one-way jumping machine with sweep complexity $\mathcal{O}(f(n))$.

Observe that the sweep complexity of a machine can be defined to also take into account the sweep count of rejected words. However, this allows to ‘artificially’ increase the sweep complexity of machines with complexity $o(n)$ without affecting regularity. Let $A$ be a machine accepting a regular language and $B$ a non-regular language with sweep complexities $f(n)$ and $g(n)$, respectively, such that $f(n)\in o(g(n))$. Then we can construct a ROWJFA accepting $aL(A)$ with sweep complexity $g(n)$ by adding a new initial state from which reading $a$ takes us to the initial state of $A$ while reading $b$ takes us to the initial state of $B$. We set all states of $B$ non-final and this way we get that on inputs starting with $b$ the machine performs $B$’s computations but never accepts anything. Moreover, $aL(A)$ is regular if and only if $L(A)$ was (see Fig. 5).

Each machine considered up to the point when the above measures were introduced [8] had either constant or, the maximal possible, linear sweep complexity, so it seemed that there is a gap between them. Moreover, the examples with linear complexity accepted non-regular languages, while as the theorem below states, the constant complexity languages are exactly the regular languages.

The sufficient condition above was conjectured to be also necessary for regularity in general, evidenced by the known examples at that point.

Next, we investigate the apparent gap between constant and linear complexities and show that the presumed condition above is not necessary for regularity. Our search for machines with non-constant sweep complexity is directed by the following structural lemma, which says that such machines need to have two ‘complementary deficient states’ in a cycle.

In this section we show that there is no sweep complexity separation between regular and non-regular languages by exhibiting automata which accept regular languages while requiring superconstant number of sweeps.

Consider first the automaton $\mathcal{B}$ with states $\{\mathbf{1},\mathbf{2},\mathbf{3}\}$ where $\mathbf{1}$ is initial and final, and transitions are $\{\mathbf{1}a\rightarrow\mathbf{2},\mathbf{2}a\rightarrow\mathbf{1},\mathbf{1}b\rightarrow\mathbf{3},\mathbf{3}b\rightarrow\mathbf{1}\}$, described in Fig. 5.

The above results showcase the existence of ROWJFAs that accept regular languages while performing a logarithmic number of sweeps. Next we construct of a ROWJFA that accepts a regular language while requiring a linear number of sweeps in the worst case. Consider the automaton $\mathcal{C}$ in Fig. 6 defined as

where the transitions from $R$ are given by the edges in the figure.

As a consequence of Propositions 2 and 3, we know that the class of regular languages has no upper bound in terms of sweep complexity, since the sweep complexity of any is in ${\mathcal{O}}(n)$. The left hand cycle in the automata $\mathcal{C}$ described in Fig. 6 also showcases that while the conditions from Lemma 1 are necessary for non-regularity (as it requires superconstant complexity), they are not sufficient.

Consider the prolongable morphism $\varphi(a)=abab$, $\varphi(b)=b$ starting from the word $ab$. We get $\varphi(ab)=ababb$, $\varphi^{2}(ab)=\varphi(ababb)=ababbababbb$, etc. The infinite word $\phi=\lim_{n\rightarrow\infty}\varphi^{n}(ab)=ababbababbb\dots$ is a fixed point of $\phi$. It is easy to see that in $\phi$ all $a$’s stand alone, that is, we never have blocks of $a$’s longer than $1$, and the lengths of the blocks of $b$’s are $1,2,1,3$, and so on¹¹1The sequence $\{c(n)\}_{n=1}^{\infty}$ given by the lengths of $b$ blocks is A001511 in OEIS; its most relevant characterization for us is that $c(n)-1$ is the number of trailing zeros in the binary expansion of $n$, since this means that $c(n)-1$ is $\log n$ for powers of $2$. When applying $\varphi$, each $a$ introduces a new block of $b$’s of length $1$ and extends a block of $b$’s by one, while the number of $a$’s doubles. Thus every other block of $b$’s gets longer by one on each application of $\varphi$, because of the $a$ preceding it. A simple inductive argument shows that the last block of $b$’s in $\varphi^{n}(ab)$ has length $n+1$, and is preceded by $2^{n}$ occurrences of $a$’s, separated by blocks of $b$’s.

In what follows we analyze the language accepted by the automaton $\mathcal{D}=\left(\{\mathbf{1},\mathbf{2},\mathbf{3}\},\{a,b\},\{\mathbf{1}a\rightarrow\mathbf{2},\mathbf{2}a\rightarrow\mathbf{2},\mathbf{2}b\rightarrow\mathbf{3},\mathbf{3}b\rightarrow\mathbf{1}\},\mathbf{1},\{\mathbf{3}\}\right)$, described in Fig. 8.

The results of Lemmas 4 and 5 mean that we have separation between $\textrm{SWEEP}(1)$ and $\textrm{SWEEP}(\log n)$.

Apart from the complexity considerations listed below we think the proof of Lemma 4 contains a detail worth emphasizing: the automaton can verify a logarithmic/exponential relation between two factors of suitably chosen inputs! We found this very surprising since we still basically deal with DFA which cannot store information and cannot ‘choose’ which symbols to read or jump over²²2Iterated uniform finite transducers can also verify such relationships, albeit their computing power is much stronger. [11].

We presented automata for all pairings of regular and non-regular languages with logarithmic and linear worst case sweep complexity. This way we disproved the conjecture on the constant sweep requirement for regularity [9] and answered several questions regarding sweep complexity posed in [8]:

1. 1.

   Is the language of each machine with $\omega(1)$ complexity non-regular? NO, by Section 3.

2. 2.

   Is there a machine with sweep complexity between constant and linear, that is, $\omega(1)$ and $o(n)$? YES, by Theorem 3.1 (and Lemma 5).

3. 3.

   Is there a language with sweep complexity between constant and linear, that is, all machines accepting it have superconstant complexity and at least one has sublinear? YES, by Theorem 4.1.

4. 4.

   Is there an upper bound in terms of sweep complexity on machines accepting regular languages? NO, by Propositions 2 and 3.

5. 5.

   Are machines less complex in the case of binary alphabets, given that the complementary deficient pairs of Lemma 1 are predetermined? NO, illustrated by the fact that all results have been obtained over a binary alphabet.

These coarser forms of Questions 2 and 3 have been answered here, but for a complete picture one would want to know whether there exist machines with arbitrary (constructible) sublinear complexity and its equivalent for languages. The most obvious choices for such a study would probably be complexities $\Theta(\log^{k}n)$ and $\Theta(n^{\epsilon})$, for constants $k>1$ and $\epsilon<1$. Another angle related to Question 4 is to study the lower bound of non-regularity: logarithmic complexity can produce non-regular languages, but can we do it with less of this ‘non-regular’ resource? In the case of Question 5, our answer may be refined, as there may by some sublinear $f(n)$ such that the machines of $\Theta(f(n))$ complexity all accept regular or all accept non-regular languages, although we have not seen anything that indicates such perplexing behaviour.

Another interesting direction relates to our original motivation in looking at the complexity of these automata, deciding regularity. The question more generally becomes, is it decidable given a machine or language and a function $f(n)$, whether the machine/language has $\Theta(f(n))$ complexity (or its one-sided variants with $\mathcal{O}$ and $\Omega$)? We suspect that the answer is yes at least in the case of constant and linear functions but have no idea about the logarithmic and more complicated cases.