Automata theory on sliding windows

TL;DR

This paper extends the analysis of space complexity for sliding window algorithms on regular languages, providing characterizations, bounds, and decision procedures for constant and logarithmic space classes.

Contribution

It offers natural characterizations for constant and logarithmic space classes and relates them to language growth, advancing understanding of automata-based streaming algorithms.

Findings

Characterizations for constant and logarithmic space classes

Tight bounds on space complexity relative to automata size

Decidability results for language classes with specific space bounds

Abstract

In a recent paper we analyzed the space complexity of streaming algorithms whose goal is to decide membership of a sliding window to a fixed language. For the class of regular languages we proved a space trichotomy theorem: for every regular language the optimal space bound is either constant, logarithmic or linear. In this paper we continue this line of research: We present natural characterizations for the constant and logarithmic space classes and establish tight relationships to the concept of language growth. We also analyze the space complexity with respect to automata size and prove almost matching lower and upper bounds. Finally, we consider the decision problem whether a language given by a DFA/NFA admits a sliding window algorithm using logarithmic/constant space.

Equations

$$\bigg{(}\frac{n}{k}\bigg{)}^{k}\leq\binom{n}{k}\leq\bigg{(}\frac{e\cdot n}{k}\bigg{)}^{k},\quad\text{for all $1\leq k\leq n$}.$$

$$\forall z\in {\Sigma }^{\ast }:xz\in L⟺yz\in L,$$

$$\forall u,v\in {\Sigma }^{\ast }:uxv\in L⟺uyv\in L.$$

$${\mathrm{last}}_n(w)=\{\begin{array}{ll}{a}_{m-n+1}{a}_{m-n+2}\cdots a_m,& \text{if }n\le m,\\ a^{n-m}{a}_1\cdots a_m,& \text{if }n>m,\end{array}$$

$$v_{\mathcal{A}}(n)=\max \{\mathrm{space}(\mathcal{A},u):u\in {\overline{\Sigma }}^{\ast },|\mathrm{wnd}(v)|\le n\text{ for all }v\in \mathrm{Pref}(u)\},$$

$$\mathcal{B}(w)=(\mathcal{A}({\tau }_{q_0}^{\mathsf{R}}(\mathrm{wnd}(w))),\dots ,\mathcal{A}({\tau }_{q_{d-1}}^{\mathsf{R}}(\mathrm{wnd}(w)))).$$

$$\mathcal{B}(w\downarrow )=(\mathcal{A}({\tau }_{q_0}^{\mathsf{R}}(\mathrm{wnd}(w))\downarrow ),\dots ,\mathcal{A}({\tau }_{q_{d-1}}^{\mathsf{R}}(\mathrm{wnd}(w))\downarrow ))$$

$${\tau }_{q_i}^{\mathsf{R}}(\mathrm{wnd}(wa))={\tau }_{p_i}^{\mathsf{R}}(\mathrm{wnd}(w))b_i$$

$$\mathcal{B}(wa)=(\mathcal{A}({\tau }_{p_0}^{\mathsf{R}}(\mathrm{wnd}(w))b_0),\dots ,\mathcal{A}({\tau }_{p_{d-1}}^{\mathsf{R}}(\mathrm{wnd}(w))b_{d-1})).$$

$${\psi }_L(a_1\cdots a_n)=[a_1\cdots a_n{]}_{{\sim }_L}[a_2\cdots a_n{]}_{{\sim }_L}\cdots [a_n{]}_{{\sim }_L}.$$

$$\mathcal{A}(x)\stackrel{y}{\to }{s}_0\stackrel{\downarrow }{\to }{s}_1\stackrel{\downarrow }{\to }{s}_2\stackrel{\downarrow }{\to }{s}_3\stackrel{\downarrow }{\to }\dots$$

$$\delta (m,a)=(h(a)\cdot m,\nu (h(a)\cdot m))$$

$$m^{m}\cdot\binom{n+m-1}{m-1}\leq m^{m}\cdot\binom{n+m}{m}\leq m^{m}\cdot\bigg{(}\frac{e\cdot(n+m)}{m}\bigg{)}^{m}\leq e^{m}\cdot(n+m)^{m}.$$

$$|\{A_w:w\in {\Sigma }^{\le n}\}|\le \sum _{i=0}^n{e}^{2^m|D|}\cdot (i+2^m{)}^{2^m|D|}\le (n+1)\cdot e^{2^m|D|}\cdot (n+2^m{)}^{2^m|D|}.$$

$$V_L(n)$$

$$w(\alpha )=u{u}_{{\alpha }_1}{v}_{{\alpha }_1}\cdots u_{{\alpha }_n}{v}_{{\alpha }_n}.$$

$$(p_1,p_2)\stackrel{u}{\to }(q_1,q_2)\text{ and }(p_1,p_2)\stackrel{v}{\to }(r_1,r_2)$$

$$(q_1,q_2)\text{ is final}$$

$$P=(p_1,C_1,q_1,a_1,p_2,C_2,q_2,a_2,\dots ,p_k,C_k,q_k)$$

$$C:q_1\stackrel{a_1}{\to }{q}_2\stackrel{a_2}{\to }{q}_3\cdots q_{m_i-1}\stackrel{a_{m_i-1}}{\to }{q}_{m_i}\stackrel{a_{m_i}}{\to }{q}_1$$

$$P:q_1^{\prime }\stackrel{w^{d_i}}{\to }{q}_1,C^{\prime }:q_1\stackrel{a_1}{\to }{q}_2\stackrel{a_2}{\to }{q}_3\cdots q_{m-1}\stackrel{a_{m-1}}{\to }{q}_m\stackrel{a_m}{\to }{q}_1,$$

$$L=\bigcup _{0\le i\le k\text{ even}}(P_i\setminus P_{i+1}).$$

$$L=\{\begin{array}{ll}({\Sigma }^{\ast }\setminus P_1)\cup (P_2\setminus P_3)\cup \cdots \cup (P_{k-2}\setminus P_{k-1})\cup P_k,& \text{if k is even}\\ ({\Sigma }^{\ast }\setminus P_1)\cup (P_2\setminus P_3)\cup \cdots \cup (P_{k-1}\setminus P_k),& \text{if k is odd.}\end{array}$$

$${\mathrm{alt}}_{L_k}(x)\le 1+{\mathrm{alt}}_{L_k}(z)=1+{\mathrm{alt}}_{L_{k-1}}(z)\le 2^{k+1}-1\le 2^{k+2}-2.$$

$${\mathrm{alt}}_{L_k}(x)\le 1+{\mathrm{alt}}_{L_{k-1}}(y)+{\mathrm{alt}}_{L_{k-1}}(z)\le 1+(2^{k+1}-2)+(2^{k+1}-2)\le 2^{k+2}-2.$$

$$\log\binom{n}{2^{k}-1}\geq\log\bigg{(}\frac{n}{2^{k}-1}\bigg{)}^{2^{k}-1}\geq\log\bigg{(}\frac{n}{2^{k}}\bigg{)}^{2^{k}-1}=(2^{k}-1)\cdot(\log n-k).$$

$$xz\in L⟺yz\in L.$$

$$L_n:=\{w\in {\Sigma }^{\ast }:{\mathrm{last}}_n(w)\in L\}$$

$$d(K,L)=\{\begin{array}{ll}\sup \{|u|:u\in K△L\}+1,& \text{if }K\ne L,\\ 0,& \text{if }K=L.\end{array}$$

$$L_n=\{w\in {\Sigma }^{\le n-1}:{\mathrm{last}}_n(w)\in L\}\cup {\Sigma }^{\ast }(L\cap {\Sigma }^n).$$

Full text

1. Introduction

1.1. Streaming algorithms

Streaming algorithms process an input sequence $a_{1}a_{2}\cdots a_{m}$ from left to right and have at time $t$ only direct access to the current data value $a_{t}$. Such algorithms have received a lot of attention in recent years, see [1] for a broad introduction. The general goal of streaming algorithms is to avoid the explicit storage of the whole data stream. Ideally, a streaming algorithm works in constant space, in which case it reduces to a deterministic finite automaton (DFA), but polylogarithmic space with respect to the input length might be acceptable, too. These small space requirements are motivated by the current explosion in the size of the input data, which makes random access to the input often infeasible. Such a scenario arises for instance when searching in large databases (e.g., genome databases or web databases), analyzing internet traffic (e.g. click stream analysis), and monitoring networks.

The first papers on streaming algorithms as we know them today are usually attributed to Munro and Paterson [34] and Flajolet and Martin [20], although the principle idea goes back to the work on online machines by Hartmanis, Lewis and Stearns from the 1960’s [33, 38]. Extremely influential for the area of streaming algorithms was the paper of Alon, Matias, and Szegedy [3].

1.2. The standard model and sliding window model.

Two variants of streaming algorithms can be found in the literature:

• •

In the standard model the algorithm reads an input stream $a_{1}a_{2}\cdots a_{m}$ of data values from left to right. At time instant $t$ it has to output the value $f(a_{1}a_{2}\cdots a_{t})$ for a certain function $f$.

• •

In the sliding window model the algorithm works on a sliding window. At time instant $t$, the active window is a certain suffix $a_{t-n+1}a_{t-n+2}\cdots a_{t}$ of $a_{1}a_{2}\cdots a_{t}$ and the algorithm has to output $f(a_{t-n+1}a_{t-n+2}\cdots a_{t})$.

For many applications the sliding window model is more appropriate. Quite often data items in a stream are outdated after a certain time, and the sliding window model is a simple way to model this. The typical application is the analysis of a time series as it may arise in medical monitoring, web tracking, or financial monitoring. In all these applications, data items are usually no longer important after a certain time. Two variants of the sliding window model can be found in the literature; see e.g. [4]:

• •

Fixed-size model: The size of the sliding window is a fixed constant (the window size). In other words: at each time instant a new data value $a_{i}$ arrives and the oldest data value from the sliding window expires.

• •

Variable-size model: The sliding window $a_{t-n+1}a_{t-n+2}\cdots a_{t}$ is determined by an adversary. At every time instant the adversary can either remove the first data value from the sliding window (expiration of a value), or add a new data value at the right end (arrival of a new value).

In the seminal paper of Datar et al. [17], where the fixed-size sliding window model was introduced, the authors show how to maintain the number of $1$’s in a sliding window of fixed size $n$ over the alphabet $\{0,1\}$ in space $\frac{1}{\varepsilon}\cdot\log^{2}n$ if one allows a multiplicative error of $1\pm\varepsilon$. A matching lower bound is proved as well in [17]. For the upper bound, Datar et al. introduced a new data structure called exponential histograms. Histogram techniques and variants have been used to approximate a large variety of statistical data over sliding windows. Let us mention the work on computation of the variance and $k$-median [5], quantiles [4], and entropy [9] over sliding windows. Other computational problems that have been considered for the sliding window model include optimal sampling [10], various pattern matching problems [11, 13, 14, 15], database querying (e.g. processing of join queries [25]) and graph problems (e.g. checking for connectivity and computation of matchings, spanners, and spanning trees [16]). Further references on the sliding window model can be found in the surveys [1, Chapter 8] and [8].

1.3. Language recognition in the streaming model.

A natural problem that has been suprisingly neglected for the streaming model is language recognition. The goal is to check whether an input string belongs to a given language $L$. Let us quote Magniez, Mathieu, and Nayak [32]: “Few applications [of streaming] have been made in the context of formal languages, which may have impact on massive data such as DNA sequences and large XML files. For instance, in the context of databases, properties decidable by streaming algorithm have been studied [36, 35], but only in the restricted case of deterministic and constant memory space algorithms.” For Magniez et al. this was the starting point to study language recognition in the streaming model. Thereby they restricted their attention to the above mentioned standard streaming model. Note that in the standard model the membership problem for a regular language is trivial to solve: One simply has to simulate a DFA on the stream and thereby only store the current state of the DFA. In [32] the authors present a randomized streaming algorithm for the (non-regular) Dyck language $D_{s}$ with $s$ pairs of parenthesis that works in space $\mathcal{O}(\sqrt{n}\log n)$ and time $\mathrm{polylog}(n)$ per symbol. Further investigations on streaming language recognition for various subclasses of context-free languages can be found in [6, 7, 21, 28, 29, 35, 36]. Let us emphasize that all these papers exclusively deal with the standard streaming model. Language recognition problems for the sliding window model have been completely neglected so far. This was the starting point for our previous paper [22].

1.4. Querying regular languages in the sliding window model.

As mentioned above, the membership problem for a regular language $L$ has a trivial constant space solution in the standard streaming model: One simply simulates a DFA for $L$ on the data stream by storing the current state. This solution does not work for the sliding window model. The problem is the removal of the left-most symbol from the sliding window. In order to check whether the active window belongs to a certain language $L$ one has to know this first symbol in general. In such a case one has to store the whole window content using $\mathcal{O}(n)$ bits (where $n$ is the window size). A simple regular language where this phenomenon arises is the language $a\{a,b\}^{*}$ of all words that start with $a$. The point is that by repeatedly checking whether the sliding window content belongs to $a\{a,b\}^{*}$, one can recover the exact content of the sliding window, which implies that every sliding window algorithm for testing membership in $a\{a,b\}^{*}$ has to use $n$ bits of storage (where $n$ is the window size).

For a function $s(n)$ let $\mathsf{F_{\mathsf{reg}}}(s(n))$ be the class of all languages $L$ with the following property: For every window size $n$ there exists an algorithm that reads a data stream, uses only space $s(n)$ and correctly decides at every time instant whether the active window (the last $n$ symbols from the stream) belongs to $L$. Note that this is a non-uniform model: for every window size $n$ we use a separate algorithm. The class $\mathsf{V_{\mathsf{reg}}}(s(n))$ of languages that have variable-size sliding window algorithm with space complexity $s(n)$ is defined similarly, see page 3.3 for details. Our main result from [22] is a space trichotomy for regular languages:

1. (i)

$\mathsf{V_{\mathsf{reg}}}(o(n))=\mathsf{F_{\mathsf{reg}}}(o(n))=\mathsf{F_{\mathsf{reg}}}(\mathcal{O}(\log n))=\mathsf{V_{\mathsf{reg}}}(\mathcal{O}(\log n))$ 2. (ii)

$\mathsf{F_{\mathsf{reg}}}(o(\log n))=\mathsf{F_{\mathsf{reg}}}(\mathcal{O}(1))$ 3. (iii)

$\mathsf{V_{\mathsf{reg}}}(o(\log n))=\mathsf{V_{\mathsf{reg}}}(\mathcal{O}(1))=$ all trivial languages (empty and universal languages)

Each of the three cases is characterized in terms of the syntactic homomorphism and the left Cayley graph of the syntactic monoid of the regular language. The precise characterizations are a bit technical; see [22] for the details.

In this paper we continue our investigation of sliding-window algorithms for regular languages. As a first contribution, we present very natural characterizations of the above classes in (i) and (ii): The languages in (i) are exactly the languages that are reducible with a Mealy machine (working from right to left) to a regular language of polynomial growth. Note that the regular languages of polynomial growth are exactly the bounded regular languages [40]. A language $L$ is bounded if $L\subseteq w_{1}^{*}w_{2}^{*}\cdots w_{n}^{*}$ for words $w_{1},w_{2},\ldots,w_{n}$. In addition, we show that the class (i) is the Boolean closure of regular left ideals (regular languages $L$ with $\Sigma^{*}L\subseteq L$) and regular length languages (regular languages where $|u|=|v|$ implies that $u\in L$ iff $v\in L$). The class (ii) is characterized as the Boolean closure of suffix-testable languages (languages $L$ where membership in $L$ only depends on a suffix of constant length) and regular length languages. A natural example for the classes above is the problem of testing whether the sliding window contains a fixed pattern $w$ as a factor (as a suffix) since we can check membership of the left ideal $\Sigma^{*}w\Sigma^{*}$ (or of the suffix-testable language $\Sigma^{*}w$).

We also consider the sliding-window space complexity of regular languages in a uniform setting, where the size $m$ (number of states) of an automaton for the regular language is also taken into account. In [22], we asked whether for DFAs of size $m$ that accept languages in $\mathsf{F_{\mathsf{reg}}}(\mathcal{O}(\log n))=\mathsf{V_{\mathsf{reg}}}(\mathcal{O}(\log n))$, there exists a sliding-window streaming algorithm with space complexity $\mathrm{poly}(m)\cdot\log n$. Here, we give a negative answer by proving a lower bound of the form $\Omega(2^{m}\cdot\log n)$. Moreover, we also show almost matching upper bounds.

Finally, we prove that one can test in nondeterministic logspace and hence in deterministic polynomial time whether for a given DFA $\mathcal{A}$ the language $L(\mathcal{A})$ belongs to the above class (i) (resp., (ii)). For NFAs these problems become Pspace-complete.

1.5. Related work.

In [19] Fijalkow defines the online space complexity of a language $L$. His definition is equivalent to the space complexity of the language $L$ in the standard streaming model described above. Among other results, Fijalkow presents a probabilistic automaton $\mathcal{A}$ such that the language accepted by $\mathcal{A}$ (with threshold $1/2$) needs space $\Omega(n)$ in the streaming model.

Streaming a language $L$ in the standard model is also related to the concept of automaticity [37]. For a language $L\subseteq\Sigma^{*}$, the automaticity $A_{L}$ of $L$ is the function $n\mapsto A_{L}(n)$, where $A_{L}(n)$ is the minimal number of states of a DFA $\mathcal{A}$ such that for all words $w$ of length at most $n$: $w\in L$ if and only if $w\in L(\mathcal{A})$. Clearly, every regular language $L$ has constant automaticity. Karp [27] proved that for every non-regular language $L$, $A_{L}(n)\geq(n+3)/2$ for infinitely many $n$. This implies that for every non-regular language $L$, membership checking in the standard streaming model is not possible in space $o(\log n)$.

2. Preliminaries

Throughout this paper we use $\log x$ as an abbreviation for $\lfloor\log_{2}x\rfloor$. Note that if $w_{1},w_{2},w_{3},\ldots$ is the length-lexicographic enumeration of all words from $\{0,1\}^{*}$ then $|w_{i}|\leq\log i$. We use the following well-known bounds for binomial coefficients, where $e$ is Euler’s constant:

[TABLE]

Assume that $u_{1},\ldots,u_{k}\in\{0,1\}^{+}$ are non-empty bit strings of total length $n=\sum_{i=1}^{k}|u_{i}|$. To encode the tuple $(u_{1},\ldots,u_{k})$ we use a simple block code: We encode each bit in $u_{i}$ except the first one by the mapping $0\mapsto 00$, $1\mapsto 01$. The first bit in each $u_{i}$ is encoded by the mapping $0\mapsto 10$, $1\mapsto 11$. Then, the resulting bit strings are concatenated, which results in an encoding with $2n$ bits. In the rest of the paper, we will use this encoding without mentioning it explicitly. In fact, more succinct encodings exist.

Let $\Sigma^{\leq n}=\{w\in\Sigma^{*}:|w|\leq n\}$. A prefix of a word $w\in\Sigma^{*}$ is a word $u\in\Sigma^{*}$ with $w=uv$ for some $v\in\Sigma^{*}$. The set of all prefixes of $w\in\Sigma^{*}$ is denoted by $\mathrm{Pref}(w)$. For a language $L\subseteq\Sigma^{*}$ we define $\mathrm{Pref}(L)=\bigcup_{w\in L}\mathrm{Pref}(w)$ to be the set of prefixes of words in $L$.

The reversal of a word $x=a_{1}\cdots a_{n}$ is defined as $x^{\mathsf{R}}=a_{n}\cdots a_{1}$ and the reversal of a language $L$ is $L^{\mathsf{R}}=\{x^{\mathsf{R}}:x\in L\}$. The reversal of a function $\tau:\Sigma^{*}\to\Gamma^{*}$ is defined as $\tau^{\mathsf{R}}(x)=\tau(x^{\mathsf{R}})^{\mathsf{R}}$. Thus, $\tau(u)=v$ if and only if $\tau^{\mathsf{R}}(u^{\mathsf{R}})=v^{\mathsf{R}}$.

2.1. Automata.

We use standard definitions from automata theory. A nondeterministic finite automaton (NFA) is a tuple $\mathcal{A}=(Q,\Sigma,I,\Delta,F)$ where $Q$ is a finite set of states, $\Sigma$ is an alphabet, $I\subseteq Q$ is the set of initial states, $\Delta\subseteq Q\times\Sigma\times Q$ is the transition relation and $F\subseteq Q$ is the set of final states. A deterministic finite automaton (DFA) $\mathcal{A}=(Q,\Sigma,q_{0},\delta,F)$ has a single initial state $q_{0}\in Q$ instead of $I$ and a transition function $\delta\colon Q\times\Sigma\to Q$ instead of the transition relation $\Delta$. A deterministic automaton has the same format as a DFA, except that the state set $Q$ is not required to be finite. If $\mathcal{A}$ is deterministic, the transition function $\delta$ is extended to a function $\delta\colon Q\times\Sigma^{*}\to Q$ in the usual way and we define $\mathcal{A}(x)=\delta(q_{0},x)$ for $x\in\Sigma^{*}$. The language accepted by $\mathcal{A}$ is denoted by $L(\mathcal{A})$.

The Myhill-Nerode congruence $\sim_{L}$ of a language $L\subseteq\Sigma^{*}$ is the equivalence relation on $\Sigma^{*}$ defined by $x\sim_{L}y$ if and only if

[TABLE]

which is a right congruence on $\Sigma^{*}$, i.e. $x\sim_{L}y$ implies $xz\sim_{L}yz$ for all $x,y,z\in\Sigma^{*}$. For a word $x\in\Sigma^{*}$ the left quotient $x^{-1}L$ is $\{z\in\Sigma^{*}:xz\in L\}$. Thus, $x\sim_{L}y$ if and only if $x^{-1}L=y^{-1}L$. If $\mathcal{A}$ is a deterministic automaton for a language $L\subseteq\Sigma^{*}$, then $\mathcal{A}(x)=\mathcal{A}(y)$ implies $x\sim_{L}y$. Furthermore, $L$ is recognized by the deterministic automaton $\mathcal{A}=(Q,\Sigma,q_{0},\delta,F)$ with state set $Q=\Sigma^{*}/{\sim_{L}}$, transition function $\delta([x]_{\sim_{L}},a)=[xa]_{\sim_{L}}$, initial state $q_{0}=[\varepsilon]_{\sim_{L}}$ and final states $F=\{[x]_{\sim_{L}}:x\in L\}$, which is the minimal deterministic automaton for $L$ (up to isomorphism).

For an NFA $\mathcal{A}$ we denote with $\mathcal{A}^{\mathsf{D}}$ the corresponding deterministic power set automaton (restricted to those states that are reachable from the initial state) and with $\mathcal{A}^{\mathsf{R}}$ the NFA obtained from $\mathcal{A}$ by reversing all transitions and swapping the set of initial states and the set of final states. Moreover, we define $\mathcal{A}^{\mathsf{RD}}=(\mathcal{A}^{\mathsf{R}})^{\mathsf{D}}$. Thus, $L(\mathcal{A}^{\mathsf{R}})=L(\mathcal{A}^{\mathsf{RD}})=L(\mathcal{A})^{\mathsf{R}}$. If an NFA $\mathcal{A}$ has $m$ states, then both $\mathcal{A}^{\mathsf{D}}$ and $\mathcal{A}^{\mathsf{RD}}$ have at most $2^{m}$ states.

A language $L\subseteq\Sigma^{*}$ is recognized by a monoid $M$, if there exists a homomorphism $h\colon\Sigma^{*}\to M$ and a set $F\subseteq M$ such that $h^{-1}(F)=L$. The syntactic congruence $\equiv_{L}$ of $L$ is defined by $x\equiv_{L}y$ if and only if

[TABLE]

It refines $\sim_{L}$, i.e., $x\equiv_{L}y$ implies $x\sim_{L}y$. The syntactic monoid of a language $L$ is the quotient monoid $\Sigma^{*}/{\equiv_{L}}$ and the mapping $h\colon\Sigma^{*}\to\Sigma^{*}/{\equiv_{L}}$, $h(x)=[x]_{\equiv_{L}}$ is the syntactic homomorphism of $L$. It is known that a language is regular if and only if its syntactic monoid is finite.

2.2. Streaming algorithms.

A data stream is just a finite sequence of data values. We make the assumption that these data values are from a finite set $\Sigma$. Thus, a data stream is a finite word $w=a_{1}a_{2}\cdots a_{m}\in\Sigma^{*}$. A streaming algorithm reads the symbols of a data stream from left to right. At time instant $t$ the algorithm has only access to the symbol $a_{t}$ and the internal storage, which is encoded by a bit string. The goal of the streaming algorithm is to compute a certain function $f\colon\Sigma^{*}\to A$ into some domain $A$, which means that at time instant $t$ the streaming algorithm outputs the value $f(a_{1}a_{2}\cdots a_{t})$. In this paper, we only consider the Boolean case $A=\{0,1\}$; in other words, the streaming algorithm tests membership of a fixed language. Furthermore, we abstract away from the actual computation and only analyze the space requirement. Formally, a streaming algorithm over $\Sigma$ is a deterministic (possibly infinite) automaton $\mathcal{A}=(S,\Sigma,s_{0},\delta,F)$, where the states are encoded by bit strings. We describe this encoding by an injective function $\mathrm{enc}\colon S\to\{0,1\}^{*}$. The space function $\mathrm{space}(\mathcal{A},\cdot)\colon\Sigma^{*}\to\mathbb{N}$ specifies the space used by $\mathcal{A}$ on a certain input: For $w\in\Sigma^{*}$ let $\mathrm{space}(\mathcal{A},w)=\max\{|\mathrm{enc}(\mathcal{A}(u))|:u\in\mathrm{Pref}(w)\}$. We also say that $\mathcal{A}$ is a streaming algorithm for the accepted language $L(\mathcal{A})$.

3. Sliding window streaming models

In the above streaming model, the output value of the streaming algorithm at time $t$ depends on the whole past $a_{1}a_{2}\cdots a_{t}$ of the data stream. However, in many practical applications one is only interested in the relevant part of the past. Two formalizations of “relevant past” can be found in the literature:

• •

Only the suffix of $a_{1}a_{2}\cdots a_{t}$ of length $n$ is relevant. Here, $n$ is a fixed constant. This streaming model is called the fixed-size sliding window model.

• •

The relevant suffix of $a_{1}a_{2}\cdots a_{t}$ is determined by an adversary. In this model, at every time instant the adversary can either remove the first symbol from the active window (expiration of a data value), or add a new symbol at the right end (arrival of a new data value). This streaming model is also called the variable-size sliding window model.

In the following two paragraphs, we formally define these two models.

3.1. Fixed-size sliding windows.

Given a word $w=a_{1}a_{2}\cdots a_{m}\in\Sigma^{*}$ and a window length $n\geq 0$, we define $\mathrm{last}_{n}(w)\in\Sigma^{n}$ by

[TABLE]

which is called the active window. Here $a\in\Sigma$ is an arbitrary symbol, which fills the initial window. A sequence $\mathcal{A}=(\mathcal{A}_{n})_{n\geq 0}$ is a fixed-size sliding window algorithm for a language $L\subseteq\Sigma^{*}$ if each $\mathcal{A}_{n}$ is a streaming algorithm for $\{w\in\Sigma^{*}:\mathrm{last}_{n}(w)\in L\}$. Its space complexity is the function $f_{\mathcal{A}}\colon\mathbb{N}\to\mathbb{N}\cup\{\infty\}$ where $f_{\mathcal{A}}(n)$ is the maximum encoding length of a state in $\mathcal{A}_{n}$.

Note that for every language $L$ and every $n$ the language $\{w\in\Sigma^{*}:\mathrm{last}_{n}(w)\in L\}$ is regular, which ensures that $\mathcal{A}_{n}$ can be chosen to be a DFA and hence $f_{\mathcal{A}}(n)<\infty$ for all $n\geq 0$. The trivial fixed-size sliding window algorithm for $L$ is the sequence $\mathcal{B}=(\mathcal{B}_{n})_{n\geq 0}$, where $\mathcal{B}_{n}$ is the DFA with state set $\Sigma^{n}$ and transitions $au\xrightarrow{b}ub$ for $a,b\in\Sigma$, $u\in\Sigma^{n-1}$. States of $\mathcal{B}_{n}$ can be encoded with $\mathcal{O}(\log|\Sigma|\cdot n)$ bits. By minimizing each $\mathcal{B}_{n}$, we obtain an optimal fixed-size sliding window algorithm $\mathcal{A}$ for $L$. Finally, we define $F_{L}(n)=f_{\mathcal{A}}(n)$. Thus, $F_{L}$ is the space complexity of an optimal fixed-size sliding window algorithm for $L$. Notice that $F_{L}$ is not necessarily monotonic. For instance, take $L=\{au\colon u\in\{a,b\}^{*},|u|\text{ odd}\}$. Then, we have $F_{L}(2n)\in\Theta(n)$ and $F_{L}(2n+1)\in O(1)$. The above trivial algorithm $\mathcal{B}$ yields $F_{L}(n)\in\mathcal{O}(n)$ for every language $L$.

Note that the fixed-size sliding window is a non-uniform model: for every window size we have a separate streaming algorithm and these algorithms do not have to follow a common pattern. Working with a non-uniform model makes lower bounds stronger. In contrast, the variable-size sliding window model that we discuss next is a uniform model in the sense that there is a single streaming algorithm that works for every window length.

3.2. Variable-size sliding windows.

For an alphabet $\Sigma$ we define the extended alphabet $\overline{\Sigma}=\Sigma\cup\{\downarrow\}$. In the variable-size model the active window $\mathrm{wnd}(u)\in\Sigma^{*}$ for a stream $u\in\overline{\Sigma}^{*}$ is defined by

• •

$\mathrm{wnd}(\varepsilon)=\varepsilon$

• •

$\mathrm{wnd}(ua)=\mathrm{wnd}(u)\cdot a$ for $a\in\Sigma$

• •

$\mathrm{wnd}(u\!\downarrow)=\varepsilon$ if $\mathrm{wnd}(u)=\varepsilon$

• •

$\mathrm{wnd}(u\!\downarrow)=v$ if $\mathrm{wnd}(u)=av$ for $a\in\Sigma$

A variable-size sliding window algorithm for a language $L\subseteq\Sigma^{*}$ is a streaming algorithm $\mathcal{A}$ for $\{w\in\overline{\Sigma}^{*}:\mathrm{wnd}(w)\in L\}$. Its space complexity is the function $v_{\mathcal{A}}\colon\mathbb{N}\to\mathbb{N}\cup\{\infty\}$ mapping each window length $n$ to the maximum number of bits used by $\mathcal{A}$ on inputs producing an active window of size at most $n$. Formally, it is the function

[TABLE]

which is a monotonic function.111The definition of $v_{\mathcal{A}}(n)$ slightly deviates from the one given in [22], namely $v^{\prime}_{\mathcal{A}}(n)=\max\{|\mathrm{enc}(\mathcal{A}(u))|:u\in\overline{\Sigma}^{*},|\mathrm{wnd}(u)|=n\}$. One easily sees that $v_{\mathcal{A}}(n)=\max_{k\leq n}v^{\prime}_{\mathcal{A}}(k)$ and hence $v_{\mathcal{A}}(n)=v^{\prime}_{\mathcal{A}}(n)$ for monotonic functions $v^{\prime}_{\mathcal{A}}(n)$.

Lemma 3.1**.**

For every language $L\subseteq\Sigma^{*}$ there exists a variable-size sliding window algorithm $\mathcal{A}$ such that $v_{\mathcal{A}}(n)\leq v_{\mathcal{B}}(n)$ for every variable-size sliding window algorithm $\mathcal{B}$ for $L$ and every $n$.

Proof.

Let $\mathcal{A}=(S,\overline{\Sigma},s_{0},\delta,F)$ be the minimal deterministic automaton for $\{w\in\overline{\Sigma}^{*}:\mathrm{wnd}(w)\in L\}$. The state set $S$ can be finite or infinite. It has the property that the active window determines the current state, i.e. $\mathcal{A}(x)=\mathcal{A}(\mathrm{wnd}(x))$ for all $x\in\overline{\Sigma}^{*}$. For $n\geq 0$ let $S_{n}\subseteq S$ be the set of states reachable in $\mathcal{A}$ from the initial state $s_{0}$ by a word over $\overline{\Sigma}$ of length at most $n$. By the aforementioned property all words $x\in\overline{\Sigma}^{*}$ with $|\mathrm{wnd}(x)|\leq n$ lead to a state $\mathcal{A}(x)=\mathcal{A}(\mathrm{wnd}(x))\in S_{n}$. Now one can define an encoding such that the space complexity of $\mathcal{A}$ is $\log|S_{n}|$: Define an enumeration of $S$ by starting with $s_{0}$, then listing (in any order) all states from $S_{1}\setminus S_{0}$, followed by the states from $S_{2}\setminus S_{1}$, and so one. Then we encode the $i$-th state from this list by the $i$-th bit string in length-lexicographical order.

Now let $\mathcal{B}$ be any variable-size sliding window algorithm for $L$. Let $T_{n}$ be the set of states reachable in $\mathcal{B}$ from the initial state by a word of length at most $n$. By reading a word of length at most $n$, the window length never exceeds $n$. Therefore, the encoding length of any $t\in T_{n}$ is bounded by $v_{\mathcal{B}}(n)$, which implies $|T_{n}|\leq 2^{v_{\mathcal{B}}(n)+1}-1$. We get $\log|T_{n}|\leq v_{\mathcal{B}}(n)$. Since $\mathcal{A}$ is minimal we have $|S_{n}|\leq|T_{n}|$ and therefore $v_{\mathcal{A}}(n)\leq v_{\mathcal{B}}(n)$. ∎

We define $V_{L}(n)=v_{\mathcal{A}}(n)$, where $\mathcal{A}$ is a space optimal variable-size sliding window algorithm for $L$ from Lemma 3.1. Since any algorithm in the variable-size model yields an algorithm in the fixed-size model, we have $F_{L}(n)\leq V_{L}(n)$.

3.3. Space complexity classes and closure properties.

For a function $s\colon\mathbb{N}\to\mathbb{N}$ we define the classes $\mathsf{F}(s)$ and $\mathsf{V}(s)$ of all languages $L\subseteq\Sigma^{*}$ which have a fixed-size (variable-size, respectively) sliding window algorithm with space complexity bounded by $s(n)$. For a class $\mathcal{C}$ of functions (here, it will be always an $\mathcal{O}$-class, $\Theta$-class or $o$-class) we define $\mathsf{X}(\mathcal{C})=\bigcup_{s\in\mathcal{C}}\mathsf{X}(s)$ for $\mathsf{X}\in\{\mathsf{F},\mathsf{V}\}$.

Several times we will make use of the simple fact that for both the fixed-size and the variable-size model, space classes form a Boolean algebra:

Lemma 3.2**.**

Let $X\in\{F,V\}$. If $L\subseteq\Sigma^{*}$ is a Boolean combination of languages $L_{1},\ldots,L_{k}\subseteq\Sigma^{*}$, then $X_{L}(n)\leq 2\sum_{i=1}^{k}X_{L_{i}}(n)$. In particular, for any function $s(n)$, the classes $\mathsf{F}(\mathcal{O}(s))$ and $\mathsf{V}(\mathcal{O}(s))$ form Boolean algebras.

Proof.

Run the sliding window-algorithms for $L_{1},\dots,L_{k}$ in parallel and encode the tuple of $k$ states by a single bit string. The output bits of the individual algorithms determine the output of the total algorithm. ∎

A Mealy machine $\mathcal{M}=(Q,\Sigma,\Gamma,q_{0},\delta)$ consists of a finite set of states $Q$, an input alphabet $\Sigma$, an output alphabet $\Gamma$, an initial state $q_{0}\in Q$ and the transition function $\delta\colon Q\times\Sigma\to Q\times\Gamma$. For every $q\in Q$ the machine computes a length-preserving transduction $\tau_{q}\colon\Sigma^{*}\to\Gamma^{*}$ in the usual way: $\tau_{q}(\varepsilon)=\varepsilon$ and if $\delta(p,a)=(q,b)$ then $\tau_{p}(au)=b\,\tau_{q}(u)$. We call $\tau_{q_{0}}^{\mathsf{R}}$ the $\leftarrow$-transduction computed by $\mathcal{M}$. Thus, a $\leftarrow$-transduction is computed by a Mealy machine that works on an input word from right to left. If $L$ is regular and $\tau$ is a $\leftarrow$-transduction, then $\tau(L)$ and $\tau^{-1}(L)$ are regular as well. A $\leftarrow$-transduction $\tau$ is called a $\leftarrow$-reduction from $K\subseteq\Sigma^{*}$ to $L\subseteq\Gamma^{*}$ if $x\in K$ if and only if $\tau(x)\in L$ for all $x\in\Sigma^{*}$.

Lemma 3.3**.**

Let $X\in\{F,V\}$. If $K$ is $\leftarrow$-reducible to $L$ via a Mealy machine with $d$ states, then $X_{K}(n)\leq 2d\cdot X_{L}(n)$. In particular, for any function $s(n)$ the classes $\mathsf{F}(\mathcal{O}(s))$ and $\mathsf{V}(\mathcal{O}(s))$ are closed under $\leftarrow$-reductions.

Proof.

We only give the proof for the variable-size model; analogous arguments hold for the fixed-size model. Let $\mathcal{A}$ be an optimal variable-size sliding window algorithm for $L$. Recall from the proof of Lemma 3.1 that $\mathcal{A}(w)=\mathcal{A}(\mathrm{wnd}(w))$ for all streams $w\in\overline{\Sigma}^{*}$. Let $\mathcal{M}=(Q,\Sigma,\Gamma,q_{0},\delta)$ be a Mealy machine such that $\tau^{\mathsf{R}}_{q_{0}}$ is a $\leftarrow$-reduction from $K$ to $L$. Let $Q=\{q_{0},\dots,q_{d-1}\}$ be the state set of $\mathcal{M}$.

We claim that there exists a sliding window algorithm $\mathcal{B}$ which given an input stream $w\in\overline{\Sigma}^{*}$ maintains an encoding of the tuple

[TABLE]

• •

On input $\downarrow$ we can compute

[TABLE]

from $\mathcal{B}(w)$.

• •

Given an input symbol $a\in\Sigma$, compute $\delta(q_{i},a)=(p_{i},b_{i})$ for all $0\leq i\leq d-1$. Since

[TABLE]

we can compute

[TABLE]

• •

The active window belongs to $L$ if and only if $\mathcal{A}(\tau_{q_{0}}^{\mathsf{R}}(\mathrm{wnd}(w)))$ is final in $\mathcal{A}$.

The above variable-size sliding window algorithm has space complexity $2d\cdot V_{L}(n)$: If $w=\overline{\Sigma}^{*}$ is such that $|\mathrm{wnd}(u)|\leq n$ for all $u\in\mathrm{Pref}(w)$, then also $|\tau_{q_{i}}^{\mathsf{R}}(\mathrm{wnd}(u))|\leq n$ for all $u\in\mathrm{Pref}(w)$, $0\leq i\leq d-1$. Hence, $|\mathcal{A}(\tau_{q_{i}}^{\mathsf{R}}(\mathrm{wnd}(u)))|\leq V_{L}(n)$ for all $u\in\mathrm{Pref}(w)$, $0\leq i\leq d-1$. Thus, every tuple $\mathcal{B}(a_{1}\cdots a_{t})$ can be encoded with at most $2d\cdot V_{L}(n)$ bits. ∎

3.4. Space trichotomy for regular languages.

In [22] we proved a trichotomy theorem on sliding window algorithms for regular languages. We identified a partition of the class of regular languages into three classes which completely characterize the sliding window space complexity in both the fixed-size and the variable-size model. One can easily see that the syntactic monoid of a language does not determine its space complexity: $\mathbb{Z}_{2}$ is the syntactic monoid of both languages $K=$ “even length” and $L=$ “even number of $a$’s” over $\{a,b\}$ but $\mathsf{V}_{K}(n)=\mathcal{O}(\log n)$ whereas $\mathsf{F}_{L}(n)=\Theta(n)$. The definition of the mentioned three classes is given in terms of the syntactic homomorphism and the left Cayley graph of the syntactic monoid of the regular language, see [22].

For $\mathsf{X}\in\{\mathsf{F},\mathsf{V}\}$ and a class $\mathcal{C}$ of functions we abbreviate $\mathsf{X}(\mathcal{C})\cap\mathsf{REG}$ by $\mathsf{X}_{\mathsf{reg}}(\mathcal{C})$, where $\mathsf{REG}$ is the class of all regular languages.

Theorem 3.4** ([22]).**

The following holds:

• •

$\mathsf{V_{\mathsf{reg}}}(o(n))=\mathsf{F_{\mathsf{reg}}}(o(n))=\mathsf{F_{\mathsf{reg}}}(\mathcal{O}(\log n))=\mathsf{V_{\mathsf{reg}}}(\mathcal{O}(\log n))$**

• •

$\mathsf{F_{\mathsf{reg}}}(o(\log n))=\mathsf{F_{\mathsf{reg}}}(\mathcal{O}(1))$**

• •

$\mathsf{V_{\mathsf{reg}}}(o(\log n))=\mathsf{V_{\mathsf{reg}}}(\mathcal{O}(1))=$* all trivial languages (empty and universal languages)*

Strictly speaking, [22, Theorem 7] only claims $\mathsf{V}_{L}(n)\notin O(1)$ for all languages $\emptyset\subsetneq L\subsetneq\Sigma^{*}$. However, the proof of [22, Theorem 7] does imply the stronger bound $\mathsf{V}_{L}(n)\notin o(\log n)$. This statement will also be reproved in the following section.

Let us comment on a subtle point. When making statements about the space complexity functions $V_{L}(n)$ and $F_{L}(n)$ it is in general important to fix the underlying alphabet. For instance according to point (iii) from Theorem 3.4 we have $V_{L}(n)\in\mathcal{O}(1)$ for the language $L=\{a\}^{*}$ if the underlying alphabet is $\{a\}$. On the other hand, if the underlying alphabet is $\{a,b\}$ then $V_{L}(n)\not\in\mathcal{O}(1)$ (in fact, $L$ then belongs to $\mathsf{V_{\mathsf{reg}}}(\Theta(\log n))$).

4. Variable-size space complexity and language growth

In this section we reprove the space trichotomy (Theorem 3.4) for the variable-size model. For this we relate the function $V_{L}(n)$ to the growth of a certain derived language and then use the well known results about the growth of regular languages. We need the following definition. For a language $L\subseteq\Sigma^{*}$ define the mapping $\psi_{L}\colon\Sigma^{*}\to(\Sigma^{*}/{\sim_{L}})^{*}$ by:

[TABLE]

Notice that $\psi_{L}$ is a length-preserving mapping from $\Sigma^{*}$ to the set of words over the alphabet $\Sigma^{*}/{\sim_{L}}$. Although $\Sigma^{*}/{\sim_{L}}$ may be infinite (namely for non-regular $L$), the image $\psi_{L}(\Sigma^{\leq n})$ has at most $|\Sigma|^{n+1}-1$ elements for each $n\geq 0$.

Theorem 4.1**.**

For every language $\emptyset\subsetneq L\subsetneq\Sigma^{*}$ we have $V_{L}(n)=\log|\psi_{L}(\Sigma^{\leq n})|$.

Proof.

We first exhibit a variable-size sliding window algorithm $\mathcal{A}$ with space complexity $\log|\psi_{L}(\Sigma^{\leq n})|$. The idea is that on input $w\in\overline{\Sigma}^{*}$ the algorithm $\mathcal{A}$ is in state $\mathcal{A}(w)=\psi_{L}(\mathrm{wnd}(w))$. Consider an active window $a_{1}\cdots a_{n}\in\Sigma^{*}$. Three observations are crucial:

• •

The state $\psi_{L}(a_{2}\cdots a_{n})$ can be obtained from the state $\psi_{L}(a_{1}\cdots a_{n})$ by removing the first $\sim_{L}$-class $[a_{1}\cdots a_{n}]_{\sim_{L}}$.

• •

From the state $\psi_{L}(a_{1}\cdots a_{n})$ and a symbol $a\in\Sigma$ one can obtain the state $\psi_{L}(a_{1}\cdots a_{n}a)=[a_{1}\cdots a_{n}a]_{\sim_{L}}[a_{2}\cdots a_{n}a]_{\sim_{L}}\cdots[a_{n}a]_{\sim_{L}}[a]_{\sim_{L}}$, since $\sim_{L}$ is a right-congruence.

• •

The first $\sim_{L}$-class in $\psi_{L}(a_{1}\cdots a_{n})$ determines whether $a_{1}\cdots a_{n}\in L$.

These remarks define a variable-size sliding window algorithm for $L$ with state set $\psi_{L}(\Sigma^{*})$. It remains to define the binary encoding of the states, This is done similarly to the proof of Lemma 3.1: List $\psi_{L}(\Sigma^{*})$ by starting with $\psi_{L}(\varepsilon)=\varepsilon$, followed by all states from $\psi_{L}(\Sigma)$ (in any order), followed by all states from $\psi_{L}(\Sigma^{2})$, and so on. The $i$-th state in this list is encoded by the $i$-th bit string in length-lexicographical order. Under this encoding the above variable-size sliding window algorithm has space complexity $\log|\psi_{L}(\Sigma^{\leq n})|$.

Conversely, consider a variable-size sliding window algorithm $\mathcal{A}$ for $L$ with space complexity $v_{\mathcal{A}}(n)$. We have to show that $v_{\mathcal{A}}(n)\geq\log|\psi_{L}(\Sigma^{\leq n})|$. Let $x=a_{1}a_{2}\cdots a_{m}\in\Sigma^{*}$ be an input word of length $m\leq n$. Notice that $|\mathrm{enc}(\mathcal{A}(x))|\leq v(m)\leq v(n)$ by the monotonicity of $v$.

We first show that $\mathcal{A}(x)$ determines $m=|x|$. Assume that $\varepsilon\in L$ (the case that $\varepsilon\notin L$ is analog), and let $y\notin L$ where $|y|$ is chosen minimally. Starting from $\mathcal{A}(x)$ we read $y$ into $\mathcal{A}$, followed by an infinite sequence of $\downarrow$. We obtain a run

[TABLE]

where $s_{m}$ is not final and for all $i>m$ the state $s_{i}$ is final, by minimality of $|y|$. Clearly this run determines $m$.

We now show that $\mathcal{A}(x)$ uniquely determines $\psi_{L}(a_{1}\cdots a_{m})$. By the above argument, we know that $\mathcal{A}(x)$ determines the window length $m$. Furthermore, $\mathcal{A}(x)$ determines every equivalence class $[a_{k}\cdots a_{m}]_{\sim_{L}}$ for $1\leq k\leq m$: Starting from $\mathcal{A}(x)$ we read $k-1$ times $\downarrow$ into $\mathcal{A}$. Then, the active window is $a_{k}\cdots a_{m}$. We can determine the left quotient $(a_{k}\cdots a_{m})^{-1}L=\{z\in\Sigma^{*}:a_{k}\cdots a_{m}z\in L\}$ by reading each word $z$ into $\mathcal{A}$ and testing whether $a_{k}\cdots a_{m}z\in L$. The left quotient in turn determines $[a_{k}\cdots a_{m}]_{\sim_{L}}$.

To sum up, we have shown that every value $\psi_{L}(x)$ for $x\in\Sigma^{\leq n}$ can be encoded by a bit string of length at most $v(n)$, namely $\mathrm{enc}(\mathcal{A}(x))$. Since there are $|\psi_{L}(\Sigma^{\leq n})|$ such values, it follows that $2^{v(n)+1}-1\geq|\psi_{L}(\Sigma^{\leq n})|$, which implies $v(n)\geq\log|\psi_{L}(\Sigma^{\leq n})|$. ∎

Note that Theorem 4.1 does not hold for $L=\emptyset$ or $L=\Sigma^{*}$. In these cases, we have $V_{L}(n)=0$ and $\log|\psi_{L}(\Sigma^{\leq n})|=\log(n+1)$.

We can use Theorem 4.1 to reprove the space trichotomy for regular languages in the variable-size sliding window model. For this, we need the following simple lemma:

Lemma 4.2**.**

If $L\subseteq\Sigma^{*}$ is regular, then $\psi_{L}$ is a $\leftarrow$-transduction. In particular, $\psi_{L}(\Sigma^{*})$ and $\psi_{L}(L)$ are regular. Furthermore $\psi_{L}$ is a $\leftarrow$-reduction from $L$ to $\psi_{L}(L)$.

Proof.

Let $h\colon\Sigma^{*}\to M$ be the syntactic homomorphism of $L$ into the syntactic monoid $M$ of $L$. Since the syntactic congruence refines the Myhill-Nerode congruence, there exists a function $\nu\colon M\to\Sigma^{*}/{\sim_{L}}$ such that $[x]_{\sim_{L}}=\nu(h(x))$ for all $x\in\Sigma^{*}$. Define the Mealy machine with the state set $M$ and transitions

[TABLE]

for all $m\in M$, $a\in\Sigma$. This Mealy machine computes the $\leftarrow$-transduction $\psi_{L}$.

If $\psi_{L}(x)=\psi_{L}(y)$ then either both or none of the words $x,y$ belong to $L$. This proves that $\psi_{L}$ is indeed a reduction from $L$ to $\psi_{L}(L)$. ∎

The growth of a language $L\subseteq\Sigma^{*}$ is the function $g(n)=|\{x\in L:|x|\leq n\}|$. Since the growth of every regular language is either $\Theta(n^{d})$ for some integer $d\geq 0$ or $\Omega(r^{n})$ for some $r>1$ [24, Section 2.3], Theorems 4.1 and 4.2 reprove the trichotomy theorem for variable-size windows: For every regular language $L$, $V_{L}(n)$ is either in $\mathcal{O}(1)$, $\Theta(\log n)$ or $\Theta(n)$. Furthermore, since $|\psi_{L}(\Sigma^{\leq n})|\geq n+1$ we have $V_{L}(n)\in\Omega(\log n)$ for every non-trivial language $L$.

Theorem 4.3**.**

If $L\subseteq\Sigma^{*}$ has growth $g(n)$, then $F_{L}(n)\in\mathcal{O}(\log g(n)+\log n)$.

Proof.

Let $n\geq 0$ be a window size and let $w_{1},\dots,w_{m}$ be an arbitrary enumeration of $L\cap\Sigma^{n}$ where $m\leq g(n)$. Assume that $w=a_{1}\cdots a_{n}\in\Sigma^{*}$ is the active window. The algorithm stores the longest suffix $v=a_{i}\cdots a_{n}$ of $w$ such that $v$ is a prefix of a word $w_{j}\in L\cap\Sigma^{n}$. Notice that $v$ can be encoded by the binary encoded number $j$ using $\log g(n)$ bits and the binary encoded number $i$ using $\log n$ bits. Of course, there may exist several words $w_{j}$ having $v$ as a prefix; in this case the concrete choice of $w_{j}$ does not matter. This information clearly suffices to check whether the active window belongs to $L$. Moreover, we can update the information: If $a_{n+1}\in\Sigma$ is the next symbol from the stream, then we distinguish the following cases:

• •

If $i>1$ and $a_{i}\cdots a_{n}a_{n+1}$ is a prefix of a word from $L\cap\Sigma^{n}$, say $w_{j^{\prime}}$, $1\leq j^{\prime}\leq m$, then we replace $i,j$ by $i-1,j^{\prime}$.

• •

Otherwise let $i<i^{\prime}\leq n+1$ be minimal such that $a_{i^{\prime}}\cdots a_{n}a_{n+1}$ is a prefix of a word from $L\cap\Sigma^{n}$, say $w_{j^{\prime}}$, $1\leq j^{\prime}\leq m$. We replace $i,j$ by $i^{\prime},j^{\prime}$.

The correctness of this algorithm is straightforward. ∎

5. Logspace sliding-window algorithms

In this section, we give a new and more natural characterization of languages in $\mathsf{V_{\mathsf{reg}}}(\mathcal{O}(\log n))$. Moreover, we analyze the influence of the size of the automaton on the $\mathcal{O}$-constant. In [22] we gave the space bound $\mathcal{O}(m^{m}\cdot(m\cdot\log(m)+\log(n)))$ if the regular language is given by a DFA with $m$ states. Below, we improve this bound to $\mathcal{O}(2^{m}\cdot m\cdot\log(n))$.

Let $\mathcal{B}=(Q,\Sigma,q_{0},\delta,F)$ be a DFA. A strongly connected component (SCC for short) of $\mathcal{B}$ is an inclusion-maximal subset $C\subseteq Q$ such that for all $p,q\in C$ there exist words $u,v\in\Sigma^{*}$ such that $\delta(p,u)=q$ and $\delta(q,v)=p$. The crucial property that enables logspace sliding-window algorithms is captured by the following definition:

Definition 5.1**.**

Let $\mathcal{B}=(Q,\Sigma,q_{0},\delta,F)$ be a DFA. An SCC $C\subseteq Q$ is well-behaved if for all $q\in C$ and $u,v\in\Sigma^{*}$ with $|u|=|v|$ and $\delta(q,u),\delta(q,v)\in C$ we have: $\delta(q,u)\in F$ if and only if $\delta(q,v)\in F$. If every SCC in $\mathcal{B}$ which is reachable from $q_{0}$ is well-behaved, then $\mathcal{B}$ is called well-behaved.

It turns out that $L\in\mathsf{V_{\mathsf{reg}}}(\mathcal{O}(\log n))$ if and only if $L^{\mathsf{R}}$ can be accepted by a well-behaved DFA, and we will prove this fact below. Thereby we determine the dependence of the constant in the $\mathcal{O}(\log n)$ bound with respect to the size of an automaton (DFA or NFA) for $L$.

Let $\mathcal{B}$ be a well-behaved DFA and let $\rho$ be a run in $\mathcal{B}$, which does not necessarily start in the initial state. Let $C_{1},\ldots,C_{k}$ be the sequence of pairwise different SCCs that are visited by $\rho$ in that particular order. The path summary of $\rho$ is the sequence $(p_{1},\ell_{1},p_{2},\ell_{2},\dots,p_{k},\ell_{k})$ where $p_{i}$ is the first state in $C_{i}$ visited by $\rho$, and $\ell_{i}\geq 0$ is the number of symbols read in $\rho$ from the first occurrence of $p_{i}$ until the first state from $C_{i+1}$ (or until the end for $p_{k}$). The number of different path summaries of runs of length $n$ in a DFA $\mathcal{B}$ with $m$ states can be bounded by ($e$ is Euler’s constant)

[TABLE]

Here, (i) $m^{m}$ is the number of sequences of $m$ states (we can repeat the last state in a path summary so that we have exactly $m$ states) and (ii) $\binom{n+m-1}{m-1}$ is the number of ordered partitions of $n$ into $m$ summands.

Theorem 5.2**.**

Let $L\subseteq\Sigma^{*}$ be regular and let $\mathcal{A}$ be a finite automaton for $L$ with $m$ states. Assume that $\mathcal{B}=\mathcal{A}^{\mathsf{R}\mathsf{D}}$ is well-behaved. There are constants $c_{m},d_{m}$ that only depend on $m$ such that the following holds:

• •

If $\mathcal{A}$ is a DFA then $V_{L}(n)\leq(2^{m}\cdot m+1)\cdot\log n\ +\ c_{m}$ for $n$ large enough.

• •

If $\mathcal{A}$ is an NFA then $V_{L}(n)\leq(4^{m}+1)\cdot\log n\ +\ d_{m}$ for $n$ large enough.

Proof.

A set $D\subseteq\Sigma^{*}$ distinguishes $L$ if for all $x,y\in\Sigma^{*}$ with $x\not\sim_{L}y$ there exists $z\in D$ such that exactly one of the words $xz$ and $yz$ belongs to $L$. If $\mathcal{A}$ is a DFA with $m$ states, then there are at most $m$ distinct left quotients $x^{-1}L$. Since every family of $m$ sets has a distinguishing set of size at most $m-1$ [18], we get a set $D$ of size at most $m-1$ that distinguishes $L$. If $\mathcal{A}$ is an NFA with $m$ states, we can clearly choose $|D|\leq 2^{m}-1$ by determinizing $\mathcal{A}$.

For a window content $w=a_{1}\cdots a_{n}$ we define a 0-1-matrix $A_{w}\colon D\times\{1,\dots,n\}\to\{0,1\}$ by $A_{w}(z,i)=1$ iff $a_{i}\cdots a_{n}z\in L$. Notice that the $i$-th column $A_{w}(\cdot,i)$ determines $[a_{i}\cdots a_{n}]_{\sim_{L}}$, and vice versa, for all $1\leq i\leq n$. In particular, the matrix $A_{w}$ determines $\psi_{L}(w)$ and vice versa. Thus, $|\psi_{L}(\Sigma^{\leq n})|=|\{A_{w}\colon w\in\Sigma^{\leq n}\}|$. By Theorem 4.1, it therefore suffices to bound $|\{A_{w}\colon w\in\Sigma^{\leq n}\}|$.

We can encode each row $A_{w}(z,\cdot)$ of $A_{w}$ succinctly as follows. Consider one row indexed by $z\in D$. Let $\rho_{z}$ be the run of $\mathcal{B}$ on the word $(wz)^{\mathsf{R}}$ and $\tilde{\rho}_{z}$ be the subrun of $\rho_{z}$ which only reads the suffix $w^{\mathsf{R}}$ of $(wz)^{\mathsf{R}}$. One can reconstruct $A_{w}(z,\cdot)$ from the path summary of $\tilde{\rho}_{z}$. Thus $A_{w}$ can be encoded by $|D|$ many path summaries. With (1) and the fact that $\mathcal{B}$ has at most $2^{m}$ states, we get the bound

[TABLE]

Hence, for the DFA case (where $|D|\leq m-1$) we have

[TABLE]

for $n$ large enough, where $c_{m}$ can be chosen as $1+2^{m}\cdot m\cdot\log e+m^{2}\cdot 2^{m}$. The calculation for the NFA case (where $|D|\leq 2^{m}-1$) is analogous. ∎

Finally, we show a linear space lower bound for the case that the reversal of $L$ is recognized by a non-well-behaved DFA.

Theorem 5.3**.**

Let $L\subseteq\Sigma^{*}$ be a regular language and $\mathcal{B}$ be a DFA which recognizes $L^{\mathsf{R}}$ and which is not well-behaved. Then $V_{L}(n)\in\Omega(n)$ and $F_{L}(n)\in\mathcal{O}(n)\setminus o(n)$.

Proof.

Let $q_{0}$ be the initial state of $\mathcal{B}$. Since $\mathcal{B}$ is not well-behaved, there are states $p,p_{0},p_{1}$ and words $u,u_{0},v_{0},u_{1},v_{1}\in\Sigma^{*}$ such that $|u_{0}|=|v_{0}|$, $p_{0}$ is not final, $p_{1}$ is final and $q_{0}\xrightarrow{u}p$, $p\xrightarrow{u_{0}}p_{0}\xrightarrow{v_{0}}p$ and $p\xrightarrow{u_{1}}p_{1}\xrightarrow{v_{1}}p$. We can ensure that $|u_{1}|=|v_{1}|$: If $k=|u_{0}v_{0}|$ and $\ell=|u_{1}v_{1}|$, we replace $v_{0}$ by $v_{0}(u_{0}v_{0})^{\ell-1}$ and $v_{1}$ by $v_{1}(u_{1}v_{1})^{k-1}$.

For any $\alpha=\alpha_{1}\cdots\alpha_{n}\in\{0,1\}^{*}$ we define the word

[TABLE]

Notice that the length of $w(\alpha)$ is $|u|+k\ell|\alpha|\in\mathcal{O}(|\alpha|)$. Let $\alpha\neq\beta$ be two bit strings of length $n$ which differ in position $i$, say $\alpha_{i}=1$ and $\beta_{i}=0$. Then $\mathcal{B}$ accepts $u\,u_{\alpha_{1}}v_{\alpha_{1}}\cdots u_{\alpha_{i}}$ but rejects $u\,u_{\beta_{1}}v_{\beta_{1}}\cdots u_{\beta_{i}}$, which are prefixes of $w(\alpha)$ and $w(\beta)$, respectively, of the same length. In particular, $\psi_{L}(w(\alpha)^{\mathsf{R}})\neq\psi_{L}(w(\beta)^{\mathsf{R}})$. Therefore, for any $n\geq 0$, the language $\psi_{L}(\Sigma^{*})$ contains at least $2^{n}$ words of length $\mathcal{O}(n)$. By Theorem 4.1 and monotonicity of $V_{L}(n)$, this implies $V_{L}(n)=\Omega(n)$. By Theorem 3.4 we also know that $F_{L}(n)\in\mathcal{O}(n)\setminus o(n)$. ∎

From Theorem 5.2 and Theorem 5.3 we obtain:

Corollary 5.4**.**

Let $\mathsf{X}\in\{\mathsf{F},\mathsf{V}\}$. A regular language $L\subseteq\Sigma^{*}$ belongs to $\mathsf{X}(\mathcal{O}(\log n))$ if and only if $L^{\mathsf{R}}$ is recognized by a well-behaved DFA.

5.1. Alternative Characterizations of $\mathsf{V_{\mathsf{reg}}}(\mathcal{O}(\log n))$

In the following we will give two further very natural characterizations of the languages in $\mathsf{V_{\mathsf{reg}}}(\mathcal{O}(\log n))=\mathsf{F_{\mathsf{reg}}}(\mathcal{O}(\log n))$ that we will also need in Section 7.

A language $L\subseteq\Sigma^{*}$ is called a left ideal (right ideal) if $\Sigma^{*}L\subseteq L$ ($L\Sigma^{*}\subseteq L$). A language $L\subseteq\Sigma^{*}$ is called a length language if for all $n\in\mathbb{N}$, either $\Sigma^{n}\subseteq L$ or $L\cap\Sigma^{n}=\emptyset$. Clearly, $L$ is a length language iff $L^{\mathsf{R}}$ is a length language, and $L$ is left ideal iff $L^{\mathsf{R}}$ is a right ideal. In this section we will prove the following theorem.

Theorem 5.5**.**

Let $L\subseteq\Sigma^{*}$ be regular. The following statements are equivalent:

1. (1)

$L\in\mathsf{F}(\mathcal{O}(\log n))$** 2. (2)

$L\in\mathsf{V}(\mathcal{O}(\log n))$** 3. (3)

$L^{\mathsf{R}}$* is recognized by a well-behaved DFA.* 4. (4)

$L$* is $\leftarrow$-reducible to a regular language of polynomial growth.* 5. (5)

$L$* is a Boolean combination of regular left ideals and regular length languages.*

The equivalence of points 1. and 2. was already shown in [22], and the equivalence of 2. and 3. was shown in the last section. The implication from 2. to 4. follows from Theorems 4.1 and 4.2. In the rest of the section, we prove the directions from 5. to 3., and from 4. to 5.

We start with two simple observations, which prove the direction from 5. to 3.

Lemma 5.6**.**

If a regular language $L\subseteq\Sigma^{*}$ is a right ideal or a length language, then the minimal DFA for $L$ is well-behaved.

Proof.

If $\mathcal{A}$ is the minimal DFA for a length language then for all states $q$ and all $u,v\in\Sigma^{*}$ with $|u|=|v|$, we have: $\delta(q,u)\in F$ if and only if $\delta(q,v)\in F$.

If $\mathcal{A}$ is the minimal DFA for a right ideal, then for all final states $q$ and all $u\in\Sigma^{*}$, the state $\delta(q,u)$ is final as well. Hence, for every SCC $C$ either all states of $C$ are final or all states of $C$ are non-final. ∎

Lemma 5.7**.**

The class of languages $L\subseteq\Sigma^{*}$ recognized by well-behaved DFAs is closed under Boolean operations.

Proof.

If $\mathcal{A}$ is well-behaved then the complement automaton $\overline{\mathcal{A}}$ is also well-behaved. Given two well-behaved DFAs $\mathcal{A}_{1},\mathcal{A}_{2}$, we claim that the product automaton $\mathcal{A}_{1}\times\mathcal{A}_{2}$ recognizing the intersection language is also well-behaved. Consider an SCC $S$ of $\mathcal{A}_{1}\times\mathcal{A}_{2}$ which is reachable from the initial state and let $(p_{1},p_{2}),(q_{1},q_{2}),(r_{1},r_{2})\in S$ such that

[TABLE]

for some words $u,v\in\Sigma^{*}$ with $|u|=|v|$. Since for $i\in\{1,2\}$ we have $p_{i}\xrightarrow{u}q_{i}$ and $p_{i}\xrightarrow{v}r_{i}$, and $\{p_{i},r_{i},q_{i}\}$ is contained in an SCC of $\mathcal{A}_{i}$ (which is also reachable from the initial state), we have

[TABLE]

and therefore $\mathcal{A}_{1}\times\mathcal{A}_{2}$ is well-behaved. ∎

It remains to show the implication from 4. to 5.

Lemma 5.8**.**

The class of Boolean combinations of regular left ideals and regular length languages is closed under pre-images of $\leftarrow$-transductions.

Proof.

For any function $\tau:\Sigma^{*}\to\Gamma^{*}$ and $K,L\subseteq\Gamma^{*}$ we have $\tau^{-1}(K\cup L)=\tau^{-1}(K)\cup\tau^{-1}(L)$ and $\tau^{-1}(\Gamma^{*}\setminus L)=\Sigma^{*}\setminus\tau^{-1}(L)$. Now assume that $\tau$ is a $\leftarrow$-transduction. Since it is length-preserving, the $\tau$-pre-image of a length language is again a length language. Finally, $\tau$-pre-images of left ideals are left ideals again because $\tau^{-1}(\Gamma^{*}L)=\Sigma^{*}\tau^{-1}(L)$. ∎

It remains to prove that every regular language of polynomial growth is a Boolean combination of regular left ideals and regular length languages. Since a language $L$ and its reversal $L^{\mathsf{R}}$ have the same growth, we can instead show that every regular language of polynomial growth is a Boolean combination of regular right ideals and regular length languages. The idea is to decompose every regular language of polynomial growth as a finite union of languages recognized by so called linear cycle automata.

In the following we will allow partial DFAs $\mathcal{A}=(Q,\Sigma,q_{0},\delta,F)$ where $\delta\colon Q\times\Sigma\to Q$ is a partial function. An SCC $C$ of a partial DFA $\mathcal{A}=(Q,\Sigma,q_{0},\delta,F)$ is called a cycle if for every $p\in C$ there exists at most one $a\in\Sigma$ such that $\delta(p,a)\in C$. Note that a singleton SCC $C=\{p\}$ such that $\delta(p,a)\neq p$ whenever $\delta(p,a)$ is defined is a cycle, too. Such a cycle is called trivial. A partial DFA $\mathcal{A}=(Q,\Sigma,q_{0},\delta,F)$ is a linear cycle automaton if

• •

for all $p,q\in Q$ there exists at most one symbol $a\in\Sigma$ such that $\delta(p,a)=q$,

• •

every SCC $C$ of $\mathcal{A}$ is a (possibly trivial) cycle,

• •

there is an enumeration $C_{1},\ldots,C_{k}$ of the SCCs of $\mathcal{A}$ such that there is exactly one transition from $C_{i}$ to $C_{i+1}$ for $1\leq i\leq k-1$, and there is no transition from $C_{i}$ to $C_{j}$ for $j>i+1$,

• •

$q_{0}$ belongs to $C_{1}$,

• •

$|F|=1$ and the unique final state belongs to $C_{k}$.

Lemma 5.9**.**

If $L$ is a regular language with polynomial growth, then $L$ is a finite union of languages recognized by linear cycle automata.

Proof.

Let $\mathcal{A}=(Q,\Sigma,q_{0},\delta,F)$ be the minimal DFA for a regular language $L\subseteq\Sigma^{*}$ of polynomial growth. We first remove from $\mathcal{A}$ all states from which no state in $F$ is reachable; then $\mathcal{A}$ becomes a partial DFA. By [24, Lemma 2] for every $q\in Q$ there exists a word $u_{q}\in\Sigma^{*}$ such that the language $\{w\in\Sigma^{*}:\delta(q,w)=q\}$ is a subset of $u_{q}^{*}$. Thus, for every SCC $C$ of $\mathcal{A}$ and every state $q\in C$ there is at most one symbol $a\in\Sigma$ with $\delta(q,a)\in C$.

A path description is a sequence

[TABLE]

where $C_{1},\dots,C_{k}$ is a chain in the partial ordering on the set of SCCs of $\mathcal{A}$, $p_{1}=q_{0}$, $p_{i},q_{i}\in C_{i}$ for all $1\leq i\leq k$, $\delta(q_{i},a_{i})=p_{i+1}$ for all $1\leq i<k$ and $q_{k}\in F$. Clearly there are only finitely many path descriptions. To every accepting run of $\mathcal{A}$ we can assign a path description, which indicates the SCCs traversed in the run and the transitions that lead from one SCC to the next SCC. We can write $L(\mathcal{A})$ as a finite union of languages over all path descriptions. For every path description $P$, we take the set of all words accepted by a run of $\mathcal{A}$ whose path description is $P$.

Consider a single path description $P=(p_{1},C_{1},q_{1},a_{1},p_{2},C_{2},q_{2},a_{2},\dots,p_{k},C_{k},q_{k})$ and let $\mathcal{B}$ be the restriction of $\mathcal{A}$ to the SCCs $C_{i}$. Furthermore all transitions between two distinct SCCs are removed except for the transitions $(q_{i},a_{i},p_{i+1})$. Finally, $q_{k}$ becomes the only final state of $\mathcal{B}$. Then $\mathcal{B}$ is indeed a linear cycle automaton. ∎

Lemma 5.10**.**

Let $\mathcal{A}$ be a linear cycle automaton. There are linear cycle automata $\mathcal{A}_{1},\dots,\mathcal{A}_{s}$ such that $L(\mathcal{A})=\bigcup_{i=1}^{s}L(\mathcal{A}_{i})$ and in each $\mathcal{A}_{i}$ each non-trivial cycle has the same length.

Proof.

Let $m_{1},\dots,m_{k}$ be the lengths of each non-trivial cycle (SCC) in $\mathcal{A}$ and $m$ be the least common multiple of $m_{1},\dots,m_{k}$. The language $L(\mathcal{A})$ is the finite union of all languages accepted by linear cycle automata that are obtained from $\mathcal{A}$ by doing the following replacement for every non-trivial cycle

[TABLE]

of $\mathcal{A}$. W.l.o.g. assume that $q_{1}$ is either the initial state of $\mathcal{A}$ or the target state of the unique transition entering $C$. Choose an arbitrary number $0\leq d_{i}<\frac{m}{m_{i}}$ (we then take the finite union over all such choices). We replace $C$ by a path $P$ of length $d_{i}m_{i}$ followed by cycle $C^{\prime}$ of length $m$, having the form

[TABLE]

where $a_{1}a_{2}\cdots a_{m}=(a_{1}a_{2}\cdots a_{m_{i}})^{m/m_{i}}$. All states on the path $P$ except for $q_{1}$ are new and also all states $q_{m_{i}+1},\ldots,q_{m}$ are new. If $q_{1}$ is the initial state of $\mathcal{A}$ then $q^{\prime}_{1}$ is the new initial state. Otherwise, the unique transition entering $C$ is redirected to the new state $q^{\prime}_{1}$. The union of the languages recognized by all automata of this form is $L(\mathcal{A})$. ∎

Lemma 5.11**.**

Let $\mathcal{A}$ be a linear cycle automaton in which each non-trivial cycle has the same length. Then $L(\mathcal{A})$ is a Boolean combination of regular right ideals and regular length-languages.

Proof.

Let $L\subseteq\Sigma^{*}$ be the language recognized by $\mathcal{A}$. There are numbers $p,q\geq 0$ such that each word in $L$ has length $p+qn$ for some $n\geq 0$. Here $q$ is the uniform length of the non-trivial cycles in $\mathcal{A}$. We claim that $L$ is the intersection of the three languages

• •

$L\Sigma^{*}$, which is a regular right ideal,

• •

$\{x\in\Sigma^{*}:\mathrm{Pref}(x)\subseteq\mathrm{Pref}(L)\}$, which is the complement of a regular right ideal,

• •

$\Sigma^{p}(\Sigma^{q})^{*}$, which is a length language.

Clearly $L$ is contained in the described intersection. Conversely, consider a word $x$ in the intersection. We have $x=yz$ where $y\in L$. Hence, $|y|=p+qn$ for some $n$. Since $|x|=p+qn^{\prime}$ for some $n^{\prime}$, the length $|z|$ is divided by $q$. Since $y\in L$, $\mathcal{A}(y)$ is the unique final state of $\mathcal{A}$, which belongs to the unique maximal SCC $C$ of $\mathcal{A}$. If $C$ is non-trivial, then it is a cycle of length $q$ and also $\mathcal{A}(yz)$ is the final state, i.e., $x\in L$. If $C$ is trivial, then $y,yz\in L$ implies $z=\varepsilon$ and $x$ is also accepted by $\mathcal{A}$. ∎

This concludes the proof for the direction from 4. to 5.

5.2. Lower bounds

Recall that the space bound in Theorem 5.2 is exponential in the number $m$ of automaton states. In the following we show that this bound is tight, already for the fixed-size sliding window model. For $k\geq 0$ we define the language $L_{k}\subseteq\{0,\dots,k\}^{*}$ by

• •

$L_{0}=0^{+}$, and

• •

$L_{k}=L_{k-1}\cup L_{k-1}\,k\,\{0,\dots,k-1\}^{*}$ for $k\geq 1$.

Observe that a word $a_{1}\cdots a_{n}\in\{0,\dots,k\}^{*}$ belongs to $L_{k}$ if and only if $n\geq 1$, $a_{1}=0$ and for each $1\leq i\leq n$ it holds that $a_{i}=0$ or $a_{i}\neq\max_{1\leq j\leq i-1}a_{j}$. We can construct a DFA $\mathcal{A}_{k}$ for $L_{k}$ with $k+3$ states, which stores the maximum value seen so far in its state, see Fig. 1.

To prove that each $L_{k}$ belongs to $\mathsf{V}(\mathcal{O}(\log n))$, we show that $L_{k}$ is a Boolean combination of regular left ideals. Given a word $x=a_{1}\cdots a_{n}\in\Sigma^{*}$ and a language $L\subseteq\Sigma^{*}$, a position $1\leq i\leq n$ is an $L$-alternation point, if exactly one of the words $a_{i}\cdots a_{n}$ and $a_{i+1}\cdots a_{n}$ belongs to $L$. Denote by $\mathrm{alt}_{L}(x)$ the number of $L$-alternation points in $x$.

Lemma 5.12**.**

Let $L\subseteq\Sigma^{*}$ be regular. Then $L$ is a Boolean combination of at most $k$ regular left ideals if and only if $\mathrm{alt}_{L}(x)\leq k$ for all $x\in\Sigma^{*}$.

Proof.

If $L$ is a Boolean combination of regular left ideals $L_{1},\dots,L_{k}$, then each $L$-alternation point in a word is an $L_{i}$-alternation point for some $1\leq i\leq k$. Since $L_{i}$ is a left ideal, each word has at most one $L_{i}$-alternating point and we obtain $\mathrm{alt}_{L}(x)\leq k$ for all $x\in\Sigma^{*}$.

Conversely, assume that $\mathrm{alt}_{L}(x)\leq k$ for all $x\in\Sigma^{*}$. Without loss of generality assume $\varepsilon\in L$, which ensures that $x\in L$ if and only if $\mathrm{alt}_{L}(x)$ is even. If $\varepsilon\not\in L$, then $x\in L$ if and only if $\mathrm{alt}_{L}(x)$ is odd, and we can argue similarly as below.

We define $P_{i}=\{x\in\Sigma^{*}:\mathrm{alt}_{L}(x)\geq i\}$ for $i\geq 0$ and write $L$ as

[TABLE]

Each $P_{i}$ is a left ideal because prolonging a word on the left only increases the number of $L$-alternation points. Furthermore, each $P_{i}$ is regular: by enriching a DFA for $L$ with a counter up to $i$, a DFA can verify that the input $x$ satisfies $\mathrm{alt}_{L}(x)\geq i$. Using the fact that $P_{0}=\Sigma^{*}$ and $P_{i}=\emptyset$ for all $i>k$, we can write $L$ as

[TABLE]

This proves that $L$ is a Boolean combination of the regular left ideals $P_{1},\dots,P_{k}$, which concludes the proof. ∎

Lemma 5.13**.**

For all $k\geq 0$ and $x\in\mathbb{N}^{*}$ we have $\mathrm{alt}_{L_{k}}(x)\leq 2^{k+2}-2$. Moreover, $V_{L_{k}}(n)\leq(2^{k+3}\cdot(k+3)+1)\cdot\log n\ +\ c_{k}$ for $n$ large enough, where $c_{k}$ only depends on $k$.

Proof.

We prove the lemma by induction on $k\geq 0$. Clearly each word has at most 2 alternation points with respect to $L_{0}=0^{+}$. Now let $k\geq 1$ and $x\in\mathbb{N}^{*}$. If all occurring numbers in $x$ are at most $k-1$, then $\mathrm{alt}_{L_{k}}(x)=\mathrm{alt}_{L_{k-1}}(x)$ and the claim follows by induction. Otherwise consider the last occurrence of a number $\geq k$ and factorize $x=y\ell z$ where $y\in\mathbb{N}^{*}$, $\ell\geq k$ and $z\in\{0,\ldots,k-1\}^{*}$. If $\ell>k$, then the first $|y|$ positions of $x$ cannot contain $L_{k}$-alternation points and we get

[TABLE]

Now assume $x=ykz$. By the definition of $L_{k}$ each $L_{k}$-alternation point in $x$ is either (i) an $L_{k-1}$-alternation point in $y$, (ii) an $L_{k-1}$-alternation point in $z$, or (iii) position $|y|+1$ (i.e., the last position, where $k$ occurs). Hence we have

[TABLE]

From Theorems 5.2, 5.5 and 5.12 we obtain $V_{L_{k}}(n)\leq(2^{k+3}\cdot(k+3)+1)\cdot\log n\ +\ c_{k}$ for $n$ large enough, where $c_{k}$ only depends on $k$. ∎

Theorem 5.14**.**

For each $k\geq 1$ there exists a language $L_{k}\subseteq\{0,\ldots,k\}^{*}$ recognized by a DFA with $k+3$ states such that $F_{L_{k}}(n)\geq(2^{k}-1)\cdot\log n-c^{\prime}_{k}$, where $c^{\prime}_{k}$ only depends on $k$.

Proof.

Of course, we take the languages $L_{k}$ considered in this section. We define the languages $Z_{0}=0^{*}$ and $Z_{k}=Z_{k-1}\;k\;Z_{k-1}$ for $k\geq 1$. An example word from $Z_{3}$ is $0010002100300010020010$. The crucial fact about words $x\in Z_{k}$ that we are using is the following: Every suffix of $x$ that starts with [math] belongs to $L_{k}$ and every suffix of $x$ that starts with $a>0$ does not belong to $L_{k}$. The former follows by induction on $k$; the latter holds since words in $L_{k}$ start with [math].

Fix some $k\geq 1$ and let $\mathcal{B}=(\mathcal{B}_{n})_{n\geq 0}$ be a fixed-size sliding window algorithm for $L_{k}$ where $S_{n}$ is the state space of $\mathcal{B}_{n}$. Let us consider window size $n$. We claim that $\mathcal{B}_{n}$ distinguishes all $\binom{n}{2^{k}-1}$ words in $Z_{k}$ of length $n$.

Claim. Let $x,y\in Z_{k}$ such that $|x|=|y|=n$ and $x\neq y$. Then $\mathcal{B}_{n}(x)\neq\mathcal{B}_{n}(y)$.

In order to get a contradiction, consider two words $x,y\in Z_{k}$ with $|x|=|y|=n$, $x\neq y$, and $\mathcal{B}_{n}(x)=\mathcal{B}_{n}(y)$. Thus, we can write $x=zau$ and $y=zbv$ with $a,b\in\{0,\ldots,k\}$, $a\neq b$. We must have $a=0$ and $b>0$ or vice versa. Assume that $a=0$ and $b>0$. Thus, $au\in L_{k}$ and $bv\not\in L_{k}$. Hence, we have $\mathrm{wnd}(x0^{|z|})=au0^{|z|}\in L_{k}$ and $\mathrm{wnd}(y0^{|z|})=bv0^{|z|}\not\in L_{k}$. But if $\mathcal{B}_{n}(x)=\mathcal{B}_{n}(y)$, then also $\mathcal{B}_{n}(x0^{|z|})=\mathcal{B}_{n}(y0^{|z|})$, which yields a contradiction.

The above claim implies that $\mathcal{B}_{n}$ has at least $\binom{n}{2^{k}-1}$ many states. Hence, the space complexity of $\mathcal{B}$ is at least

[TABLE]

This concludes the proof. ∎

6. Constant space algorithms

Theorem 4.1 implies that $V_{L}(n)\geq\log n$ if $\emptyset\neq L\neq\Sigma^{*}$. Thus, only trivial languages have a constant-space variable-size streaming algorithm. This changes in the fixed-size window model. In [22] we characterized those regular languages $L$ in $\mathsf{F}(\mathcal{O}(1))$ in terms of the left Cayley graph of the syntactic monoid of $L$. Here we give a more natural characterization that will be used in the next section.

A language $L\subseteq\Sigma^{*}$ is called $k$-suffix testable if for all $x,y\in\Sigma^{*}$ and $z\in\Sigma^{k}$ we have

[TABLE]

Equivalently, $L$ is a Boolean combination of languages of the form $\Sigma^{*}w$ where $w\in\Sigma^{\leq k}$. We call $L$ suffix testable if it is $k$-suffix testable for some $k\geq 0$. Clearly, every finite language is suffix testable: if $L\subseteq\Sigma^{\leq k}$ then $L$ is $(k+1)$-suffix testable. The class of suffix testable languages corresponds to the variety $\mathbf{D}$ of definite monoids [39].

Recall the languages

[TABLE]

recognized by a family of streaming algorithms in the fixed-size model. The main result of this section is:

Theorem 6.1**.**

A regular language $L\subseteq\Sigma^{*}$ belongs to $\mathsf{F}(\mathcal{O}(1))$ if and only if $L$ is a finite Boolean combination of suffix testable languages and regular length languages.

The following definitions are useful, which are also studied in [23]. For two languages $K,L\subseteq\Sigma^{*}$, we denote by $K\triangle L=(K\setminus L)\cup(L\setminus K)$ the symmetric difference of $K$ and $L$. We define the distance $d(K,L)$ by

[TABLE]

Notice that $d(K,L)<\infty$ if and only if $K\triangle L$ is finite. For a DFA $\mathcal{A}=(Q,\Sigma,q_{0},\delta,F)$ and a state $p\in Q$, we define $\mathcal{A}_{p}=(Q,\Sigma,p,\delta,F)$. For two states $p,q\in Q$, we define the distance $d(p,q)=d(L(\mathcal{A}_{p}),L(\mathcal{A}_{q}))$. It is known that $d(p,q)<\infty$ implies $d(p,q)\leq|Q|$, see [23, Lemma 1].

Lemma 6.2**.**

Let $L\subseteq\Sigma^{*}$ be regular and $\mathcal{A}=(Q,\Sigma,q_{0},\delta,F)$ be its minimal DFA. We have:

1. (i)

$d(p,q)\leq k$* if and only if $\delta(p,z)=\delta(q,z)$ for all $p,q\in Q$ and $z\in\Sigma^{k}$.* 2. (ii)

$L$* is $k$-suffix testable if and only if $d(p,q)\leq k$ for all $p,q\in Q$.* 3. (iii)

If there exists $k\geq 0$ such that $L$ is $k$-suffix testable, then $L$ is $|Q|$-testable.

Proof.

The proof of (i) is an easy induction: If $k=0$, the statement is $d(p,q)=0$ iff $p=q$, which is true because $\mathcal{A}$ is minimal. For the induction step, we have $d(p,q)\leq k+1$ iff $d(\delta(p,a),\delta(q,a))\leq k$ for all $a\in\Sigma$ iff $\delta(p,z)=\delta(q,z)$ for all $z\in\Sigma^{k+1}$.

For (ii), assume that $L$ is $k$-suffix testable and consider two states $p=\mathcal{A}(x)$ and $q=\mathcal{A}(y)$. If $z\in L(\mathcal{A}_{p})\triangle L(\mathcal{A}_{q})$, then $|z|<k$ because $xz\in L$ iff $yz\notin L$ and $L$ is $k$-suffix testable.

Now assume that $d(p,q)\leq k$ for all $p,q\in Q$ and consider $x,y\in\Sigma^{*}$, $z\in\Sigma^{k}$. Since $d(\mathcal{A}(x),\mathcal{A}(y))\leq k$, (i) implies $\mathcal{A}(xz)=\mathcal{A}(yz)$, and in particular $xz\in L$ iff $yz\in L$. Therefore, $L$ is $k$-suffix testable.

Point (iii) follows from (ii) and the above mentioned results from [23, Lemma 1]. ∎

Theorem 6.3**.**

For any $L\subseteq\Sigma^{*}$ and $n\geq 0$, the language $L_{n}$ from (2) is $(2^{F_{L}(n)+1}-1)$-suffix testable.

Proof.

Let $(\mathcal{A}_{n})_{n\geq 0}$ be an optimal fixed-size sliding window algorithm for $L$ where $\mathcal{A}_{n}=(S_{n},\Sigma,s_{n},\delta_{n},F_{n})$, which is the minimal DFA for $L_{n}$. For every $n$, the language $L_{n}$ is $n$-suffix testable because

[TABLE]

By Lemma 6.2(iii) every language $L_{n}$ is $|S_{n}|$-suffix testable. Together with $F_{L}(n)=\log|S_{n}|$ this proves the claim for $L_{n}$. ∎

Corollary 6.4**.**

A language $L\subseteq\Sigma^{*}$ belongs to $\mathsf{F}(\mathcal{O}(1))$ if and only if there exists a $k\geq 0$ such that $L_{n}$ is $k$-suffix testable for all $n\geq 0$.

Proof.

The left-to-right direction follows from Theorem 6.3. If each $L_{n}$ is $k$-suffix testable, then the streaming algorithm for window length $n$ only needs to maintain the last $k$ symbols to test membership of a word of length $n$ in $L_{n}$, or equivalently in $L$. ∎

Proof of Theorem 6.1.

First, let $L\subseteq\Sigma^{*}$ be a regular language in $\mathsf{F}(\mathcal{O}(1))$. By Theorem 6.3 there exists $k\geq 0$ such that $L_{n}$ is $k$-suffix testable for all $n\geq 0$. We write $L$ as the Boolean combination

[TABLE]

where $Lz^{-1}=\{x\in\Sigma^{*}:xz\in L\}$ is the regular right quotient of $L$ by $z$. The set $L\cap\Sigma^{\leq k-1}$ is finite and hence suffix testable. It remains to show that each $Lz^{-1}$ is a length language. Consider two words $x,y\in\Sigma^{*}$ of the same length $|x|=|y|=n$. Since $|xz|=|yz|=n+k$ and $L_{n+k}$ is $k$-suffix testable we have $xz\in L$ iff $yz\in L$, and hence $x\in Lz^{-1}$ iff $y\in Lz^{-1}$.

For the other direction note that:

• •

if $L$ is a length language or suffix testable language then clearly $L\in\mathsf{F}(\mathcal{O}(1))$, and

• •

$\mathsf{F}(\mathcal{O}(1))$ is closed under Boolean operations by Lemma 3.2.

This proves the theorem. ∎

We give another characterization of the regular languages in $\mathsf{F}(\mathcal{O}(1))$, which yields a decision procedure in the next section.

Proposition 6.5**.**

Let $L\subseteq\Sigma^{*}$ be regular and $\mathcal{A}=(Q,\Sigma,q_{0},\delta,F)$ be its minimal DFA. Then $L\in\mathsf{F}(\mathcal{O}(1))$ if and only if for all $x,y\in\Sigma^{*}$ with $|x|=|y|$ and $z\in\Sigma^{|Q|}$ we have $\mathcal{A}(xz)=\mathcal{A}(yz)$.

Proof.

Assume that $L\in\mathsf{F}(\mathcal{O}(1))$. By Corollary 6.4 there exists $k\geq 0$ such that each $L_{n}$ is $k$-suffix testable. Let $x,y\in\Sigma^{*}$ with $|x|=|y|=n$. For all $z\in\Sigma^{k}$ we have $xz\in L_{n+k}$ iff $yz\in L_{n+k}$. Thus, $xz\in L$ iff $yz\in L$ and hence $d(\mathcal{A}(x),\mathcal{A}(y))\leq k$. This implies $d(\mathcal{A}(x),\mathcal{A}(y))\leq|Q|$. By Lemma 6.2(i) we have $\mathcal{A}(xz)=\mathcal{A}(yz)$ for all $z\in\Sigma^{|Q|}$.

Conversely, assume that $\mathcal{A}(xz)=\mathcal{A}(yz)$ for all $x,y\in\Sigma^{*}$ with $|x|=|y|$ and $z\in\Sigma^{|Q|}$. This means that one can simulate the automaton on the active window by only storing the last $|Q|$ many symbols and hence in space $\mathcal{O}(1)$. ∎

7. Deciding space complexity in the sliding window model

In this section, we consider the complexity of the following decision problems:

• •

Dfa$(1)$: Given a DFA $\mathcal{A}$, does $L(\mathcal{A})\in\mathsf{F}(\mathcal{O}(1))$ hold?

• •

Nfa$(1)$: Given an NFA $\mathcal{A}$, does $L(\mathcal{A})\in\mathsf{F}(\mathcal{O}(1))$ hold?

• •

Dfa$(\log n)$: Given a DFA $\mathcal{A}$, does $L(\mathcal{A})\in\mathsf{F}(\mathcal{O}(\log n))=\mathsf{V}(\mathcal{O}(\log n))$ hold?

• •

Nfa$(\log n)$: Given an NFA $\mathcal{A}$, does $L(\mathcal{A})\in\mathsf{F}(\mathcal{O}(\log n))=\mathsf{V}(\mathcal{O}(\log n))$ hold?

It is straightforward to show that membership in $\mathsf{V}(\mathcal{O}(1))$ for a regular language that is given by a DFA (resp., an NFA) is NL-complete (resp., Pspace-complete): By Theorem 3.4 one has to check whether $L(\mathcal{A})=\emptyset$ or $L(\mathcal{A})=\Sigma^{*}$, and universality for DFAs (resp., NFAs) is NL-complete (resp., Pspace-complete). In Section 7.1 (resp., Section 7.2) we show that Dfa$(1)$ and Dfa$(\log n)$ (resp., Nfa$(1)$ and Nfa$(\log n)$) are NL-complete (resp., Pspace-complete).

7.1. The DFA case

We start with the NL-hardness for the DFA case:

Theorem 7.1**.**

Dfa$(1)$* and Dfa$(\log n)$ are NL-hard.*

Proof.

We reduce from the NL-complete reachability problem in finite directed graphs. Given a finite directed graph $G=(V,E)$ and two vertices $s,t\in V$, the question is whether there exists a path from $s$ to $t$. We can assume that $s\neq t$ and that each vertex $v\in V$ has exactly two successors $v_{a},v_{b}\in V$. Let $\mathcal{A}=(V\cup\{\bot\},\{a,b,c\},s,\delta,\{t\})$ be a DFA where

[TABLE]

Since $s\neq t$, we can write $L(\mathcal{A})$ as $K\,\{a,b,c\}^{*}$ for some $K\subseteq\{a,b\}^{+}$. Furthermore, there exists a path from $s$ to $t$ in $G$ if and only if $K\neq\emptyset$. If $K=\emptyset$, then $L(\mathcal{A})=\emptyset$ belongs to $\mathsf{F}(\mathcal{O}(1))$ and to $\mathsf{V}(\mathcal{O}(\log n))$. If $K\neq\emptyset$, then we claim that $L(\mathcal{A})=K\;\{a,b,c\}^{*}$ does not belong to $\mathsf{V}(\mathcal{O}(\log n))$. Consider a variable-size sliding window algorithm $\mathcal{M}$ for $L(\mathcal{A})$. Fix an arbitrary word $x\in K$ and let $k=|x|$. Moreover, let $n\geq 0$ and consider the set $\{x,c^{k}\}^{n}$ of size $2^{n}$. Let us read two distinct words from $\{x,c^{k}\}^{n}$ into two instances of $\mathcal{M}$. We can write these words as $uxw$ and $vc^{k}w$ for some $u,v,w\in\{a,b,c\}^{*}$ with $|u|=|v|$. By removing the first $|u|=|v|$ many symbols from the window, we obtain the active windows $xw\in L(\mathcal{A})$ and $c^{k}w\notin L(\mathcal{A})$ and therefore $\mathcal{M}(uxw)\neq\mathcal{M}(vc^{k}w)$. Hence, $\mathcal{M}$ must contain at least $2^{n}$ many states that are reachable by words of length $kn$. This implies that $L(\mathcal{A})\notin\mathsf{V}(o(n))$. ∎

Theorem 7.2**.**

Dfa$(1)$* is NL-complete.*

Proof.

Let us first assume that the input DFA $\mathcal{A}$ is minimal. Later, we will argue how to handle the general case. Since nondeterministic logspace is closed under complement, it suffices to decide whether $L(\mathcal{A})\notin\mathsf{F}(\mathcal{O}(1))$. By Proposition 6.5 this is the case if and only if there exist words $x,y,z\in\Sigma^{*}$ such that $|x|=|y|$, $|z|=|Q|$ and $\mathcal{A}(xz)\neq\mathcal{A}(yz)$. The existence of such words can be easily verified in nondeterministic logspace: One simulates $\mathcal{A}$ on two words of the same length (the words $x,y$), and thereby only stores the current state pair. At every time instant, the algorithm can nondeterministically decide to continue the simulation from the current state pair $(p,q)$ with a single word (the word $z$) for $|Q|$ steps. The algorithm accepts if at the end the two states are distinct.

The general case, where $\mathcal{A}$ is not minimal is handled as follows: Assume that $\mathcal{A}=(\{1,\ldots,k\},\Sigma,1,\delta,F)$ is the input DFA. It is known that DFA equivalence is in NL[12]. Hence, one can test in nondeterministic logspace, whether two states $p,q\in Q$ are equivalent (in the sense that $\delta(p,w)\in F$ iff $\delta(q,w)\in F$ for all $w\in\Sigma^{*}$). We will use this problem as an NL-oracle in the above NL-algorithm for minimal DFAs. More precisely, let $\mathcal{A}^{\prime}=(Q,\Sigma,1,\delta^{\prime},F^{\prime})$ be the minimal DFA for $\mathcal{A}$, where we assume that $Q$ is the set of all states $q\in\{1,\ldots,k\}$ such that there is no state $p<q$ that is equivalent to $q$. We run the NL-algorithm above for minimal DFAs on $\mathcal{A}^{\prime}$ without explicitly constructing $\mathcal{A}^{\prime}$. If we have to compute a successor state $\delta^{\prime}(q,a)$ (where $q\in Q$) we compute, using the above NL-oracle the smallest state that is equivalent to $\delta(q,a)$.

The above argument shows that Dfa$(1)$ belongs to $\textsc{NL}^{\textsc{NL}}$. Finally, we use the well-known identity $\textsc{NL}=\textsc{NL}^{\textsc{NL}}$ [26]. ∎

In the rest of the section, we show that one can also decide in nondeterministic logspace whether $L\in\mathsf{V}(\mathcal{O}(\log n))$ (or equivalently $L\in\mathsf{F}(\mathcal{O}(\log n))$). As in the proof of Theorem 7.2 we can assume that $L$ is given by its minimal DFA $\mathcal{A}$.

For words $u,x_{0},x_{1}\in\Sigma^{*}$ we define

[TABLE]

which is the set of states of $\mathcal{A}$ reachable from the initial state by first reading $u$ and then an arbitrary product of copies of $x_{0}$ and $x_{1}$.

Lemma 7.3**.**

We have $V_{L}(n)\in\Theta(n)$ if and only if there are words $u_{0},u_{1},v_{0},v_{1}\in\Sigma^{*}$ such that $|u_{0}|=|u_{1}|\geq 1$ and $Q(u_{0},v_{0}u_{0},v_{1}u_{1})\cap Q(u_{1},v_{0}u_{0},v_{1}u_{1})=\emptyset$.

Proof.

Let $\mathcal{B}$ be the minimal DFA for $L^{\mathsf{R}}$. If $V_{L}\in\Theta(n)$, then $\mathcal{B}$ is not well-behaved, i.e., there are words $u,u_{0},u_{1},v_{0},v_{1}\in\Sigma^{*}$ such that

• •

$|u_{0}|=|u_{1}|$,

• •

$\mathcal{B}(uu_{0}v_{0})=\mathcal{B}(u)=\mathcal{B}(uu_{1}v_{1})$,

• •

$\mathcal{B}(uu_{0})\notin F$ and $\mathcal{B}(uu_{1})\in F$ (and thus $u_{0},u_{1}\in\Sigma^{+}$).

Setting $K=\{u_{0}v_{0},u_{1}v_{1}\}^{*}$ we get $uKu_{0}\cap L^{\mathsf{R}}=\emptyset$ and $uKu_{1}\subseteq L^{\mathsf{R}}$. Hence for all $w_{0}\in u_{0}^{\mathsf{R}}K^{\mathsf{R}}$ and $w_{1}\in u_{1}^{\mathsf{R}}K^{\mathsf{R}}$ we have $w_{0}\not\sim_{L}w_{1}$. Since $\mathcal{A}$ is minimal, this implies $\{\mathcal{A}(w):w\in u_{0}^{\mathsf{R}}K^{\mathsf{R}}\}\cap\{\mathcal{A}(w):w\in u_{1}^{\mathsf{R}}K^{\mathsf{R}}\}=\emptyset$, i.e., $Q(u_{0}^{\mathsf{R}},v_{0}^{\mathsf{R}}u_{0}^{\mathsf{R}},v_{1}^{\mathsf{R}}u_{1}^{\mathsf{R}})\cap Q(u_{1}^{\mathsf{R}},v_{0}^{\mathsf{R}}u_{0}^{\mathsf{R}},v_{1}^{\mathsf{R}}u_{1}^{\mathsf{R}})=\emptyset$.

Next, assume that $Q(u_{0},v_{0}u_{0},v_{1}u_{1})\cap Q(u_{1},v_{0}u_{0},v_{1}u_{1})=\emptyset$ and $|u_{0}|=|u_{1}|\geq 1$ for words $u_{0},u_{1},v_{0},v_{1}$. We clearly have $u_{0}\neq u_{1}$ and hence $v_{0}u_{0}\neq v_{1}u_{1}$. Further, we can choose numbers $p,q\geq 1$ such that $(v_{0}u_{0})^{p}$ and $(v_{1}u_{1})^{q}$ have the same length. We redefine $v_{0}$ to be $(v_{0}u_{0})^{p-1}v_{0}$ and $v_{1}$ to be $(v_{1}u_{1})^{q-1}v_{1}$. Thus, $|v_{0}u_{0}|=|v_{1}u_{1}|$. Moreover, the new resulting sets $Q(u_{i},v_{0}u_{0},v_{1}u_{1})$ are contained in the original sets, and are therefore also disjoint. Let $c=|v_{0}u_{0}|=|v_{1}u_{1}|\geq 1$.

Now consider a variable-size sliding window algorithm $\mathcal{M}$ for $L$ and let $n$ be arbitrary. We claim that for all $w_{0},w_{1}\in\{v_{0}u_{0},v_{1}u_{1}\}^{n}$ with $w_{0}\neq w_{1}$, we have $\mathcal{M}(w_{0})\neq\mathcal{M}(w_{1})$. This is because after removing a suitable number of symbols, the active windows contain words $x_{0}\in u_{0}\{v_{0}u_{0},v_{1}u_{1}\}^{*}$ and $x_{1}\in u_{1}\{v_{0}u_{0},v_{1}u_{1}\}^{*}$, respectively. By assumption, reading $x_{0}$ and $x_{1}$ in the minimal DFA $\mathcal{A}$ leads to different states. Hence there exists a word $z\in\Sigma^{*}$ such that $x_{0}z\in L$ if and only if $x_{1}z\notin L$. Thus, we must have $\mathcal{M}(x_{0})\neq\mathcal{M}(x_{1})$ and therefore $\mathcal{M}(w_{0})\neq\mathcal{M}(w_{1})$.

Since $\{v_{0}u_{0},v_{1}u_{1}\}^{n}$ consists of $2^{n}$ many words, there exists $w\in\{v_{0}u_{0},v_{1}u_{1}\}^{n}$ such that the encoding of $\mathcal{M}(w)$ has length at least $n$. Since $|w|=cn$, we have $V_{L}(n)\geq\lfloor n/c\rfloor$. ∎

We call a tuple $(u_{0},u_{1},w_{0},w_{1})$ of words critical, if $|u_{0}|=|u_{1}|\geq 1$, $u_{i}$ is a suffix of $w_{i}$ for all $i\in\{0,1\}$ and $Q(u_{0},w_{0},w_{1})\cap Q(u_{1},w_{0},w_{1})=\emptyset$. Clearly, the condition from Lemma 7.3 is equivalent to the existence of a critical tuple.

Lemma 7.4**.**

If there exists a critical tuple, then there exists a critical tuple $(u_{0},u_{1},w_{0},w_{1})$ such that $Q(u_{0},w_{0},w_{1})$ and $Q(u_{1},w_{0},w_{1})$ have each size at most three.

Proof.

Let $h\colon\Sigma^{*}\to M$ be the canonical homomorphism into the transition monoid $M$ of $\mathcal{A}$, which right acts on $Q$ via $Q\times M\to Q$, $(q,m)\mapsto q\cdot m=m(q)$. Assume that $(u_{0},u_{1},w_{0},w_{1})$ is a critical tuple. Notice that

[TABLE]

where $X^{*}$ denotes the submonoid of $M$ generated by a set $X\subseteq M$. It suffices to define a new critical tuple $(u_{0},u_{1},x_{0},x_{1})$ with the property that $h(x_{i})\cdot h(x_{j})=h(x_{j})$ for all $i,j\in\{0,1\}$. This implies $\{h(x_{0}),h(x_{1})\}^{*}=\{1,h(x_{0}),h(x_{1})\}$, and hence, $Q(u_{i},x_{0},x_{1})$ contains at most three elements for both $i\in\{0,1\}$.

Notice that if $(u_{0},u_{1},w_{0},w_{1})$ is critical, then also $(u_{0},u_{1},y_{0}w_{0},y_{1}w_{1})$ is critical for all $y_{0},y_{1}\in\{w_{0},w_{1}\}^{*}$. Let $\omega\geq 1$ be a number such that $m^{\omega}$ is idempotent for all $m\in M$. By choosing $e_{0}=(h(w_{0})^{\omega}h(w_{1})^{\omega})^{\omega}h(w_{0})^{\omega}$ and $e_{1}=(h(w_{0})^{\omega}h(w_{1})^{\omega})^{\omega}$ we indeed obtain $e_{i}e_{j}=e_{j}$ for all $i,j\in\{0,1\}$. Hence we define $x_{0}=(w_{0}^{\omega}w_{1}^{\omega})^{\omega}w_{0}^{\omega}$ and $x_{1}=(w_{0}^{\omega}w_{1}^{\omega})^{\omega}$. ∎

Lemma 7.5**.**

Given a minimal DFA $\mathcal{A}$, one can test in nondeterministic logspace whether $\mathcal{A}$ has a critical tuple.

Proof.

Let $\mathcal{A}=(Q,\Sigma,q_{0},\delta,F)$ be a minimal DFA. Fig. 2 illustrates the structure we need to detect in $\mathcal{A}$. To do so, we reduce to testing emptiness of one-counter automata, which is known to be decidable in nondeterministic logspace [30]. For two states $p,r\in Q$ let $\mathcal{A}_{p,r}=(Q,\Sigma,p,\delta,\{r\})$, i.e., the automaton $\mathcal{A}$ with initial state $p$ and final state $r$, and let $L(p,r)=L(\mathcal{A}_{p,r})$.

The algorithm iterates over all disjoint sets $\{p,p_{0},p_{1}\},\{r,r_{0},r_{1}\}\subseteq Q$. For $i\in\{0,1\}$ let $\mathcal{A}_{i}$ be a DFA for the language

[TABLE]

Now consider the language

[TABLE]

for which one can construct in logspace a one-counter automaton. The counter is used to verify the constraint $|u_{0}|=|u_{1}|$. The language above is empty if and only if $\mathcal{A}$ has a critical tuple. ∎

Lemma 7.3, Lemma 7.5 and Theorem 3.4 together imply:

Corollary 7.6**.**

Dfa$(\log n)$* is NL-complete.*

7.2. The NFA case

In this section, we show that the problems Nfa$(1)$ and Nfa$(\log n)$ are both Pspace-complete. The upper bounds follow easily from Theorem 7.2 and Corollary 7.6 and the following fact (see [31, Lemma 1]): If a mapping $f$ can be computed by a Turing-machine with a polynomially bounded work tape (the output can be of exponential size) and $L$ is a language that can be decided in polylogarithmic space, then $f^{-1}(L)$ belongs to Pspace. Note that from a given NFA $\mathcal{A}$ one can compute an equivalent DFA using polynomially bounded work space: One iterates over all subsets of the state set of $\mathcal{A}$; the current subset is stored on the work tape. For every subset and input symbol one then writes the corresponding transition of the DFA on the output tape.

Theorem 7.7**.**

Nfa$(1)$* is Pspace-complete.*

Proof.

By the above remark it suffices to establish Pspace-hardness of Nfa$(1)$. For this we will reduce the NFA universality problem to Nfa$(1)$. The NFA universality problem is Pspace-complete [2]. W.l.o.g. consider the alphabet $\Sigma=\{a,b\}$. For an NFA $\mathcal{A}=(Q,\Sigma,I,\Delta,F)$ we define $\rho(\mathcal{A})$ to be the automaton that results from $\mathcal{A}$ by adding a new initial state $\bar{q}$ with an $a$-labeled self-loop and a $b$-labeled transition from every state of $F$ to $\bar{q}$. The only final state of $\rho(\mathcal{A})$ is $\bar{q}$. More formally, we define $\rho(\mathcal{A})$ as follows:

[TABLE]

Notice that the $\rho$-construction implies $L(\rho(\mathcal{A}))=a^{*}\cup L(\mathcal{A})\,b\,a^{*}$. It is then easy to verify that $L(\mathcal{A})=\Sigma^{*}$ iff $L(\rho(\mathcal{A}))=\Sigma^{*}$. If $L(\mathcal{A})=\Sigma^{*}$ then clearly $L(\rho(\mathcal{A}))=\Sigma^{*}\in F(1)$. Conversely, assume that $L(\rho(\mathcal{A}))=a^{*}\cup L(\mathcal{A})\,b\,a^{*}$ belongs to $F(1)$. By Theorem 6.1 there exists a number $k\in\mathbb{N}$ such that $a^{*}\cup L(\mathcal{A})\,b\,a^{*}$ is a Boolean combination of $k$-suffix testable languages and regular length languages. Let $x\in\{a,b\}^{n}$ be any word of length $n$. Since $a^{n+1+k}\in L(\rho(\mathcal{A}))$ and $xba^{k}$ share the same $k$-suffix and are of the same length, we also know that $xba^{k}\in L(\rho(\mathcal{A}))$ and hence $x\in L(\mathcal{A})$. This proves that $\mathcal{A}$ is universal.

We have thus established that the polynomial-time (in fact, log-space) construction $\mathcal{A}\mapsto\rho(\mathcal{A})$ reduces the universality problem for NFAs to Nfa$(1)$. ∎

Theorem 7.8**.**

Nfa$(\log n)$* is Pspace-complete.*

Proof.

It remains to show that Nfa$(\log n)$ is Pspace-hard, which can be shown by reducing the NFA universality problem to Nfa$(\log n)$. W.l.o.g. the alphabet of the input automaton is $\Sigma=\{a,b\}$, and we also consider the extended alphabet $\Gamma=\{a,b,c\}$. For an NFA $\mathcal{A}=(Q,\Sigma,I,\Delta,F)$ we define $\rho(\mathcal{A})$ to be the automaton that results from $\mathcal{A}$ by adding a new initial and final state $\bar{q}$ with $a$- and $b$-labeled self-loops, a $c$-labeled transition from every state of $F$ to $\bar{q}$, and a $c$-labeled transition from $\bar{q}$ to every state of $\mathcal{A}$. The only final state of $\rho(\mathcal{A})$ is $\bar{q}$. More formally, we define

[TABLE]

The automaton $\sigma(\mathcal{A})$ results from $\mathcal{A}$ be adding a new initial and final state $\bar{q}$ with $a$- and $b$-labeled self-loops, a $c$-labeled transition from $\bar{q}$ to each initial state of $\mathcal{A}$, and a $c$-labeled transition from every state of $\mathcal{A}$ to $\bar{q}$. The only initial state of $\sigma(\mathcal{A})$ is $\bar{q}$. More formally, we define $\sigma(\mathcal{A})$ as follows:

[TABLE]

Then, we have $\rho(\mathcal{A})^{\mathsf{R}}=\sigma(\mathcal{A}^{\mathsf{R}})$, which is also equal to

[TABLE]

Notice that for a deterministic $\mathcal{A}$ (over the alphabet $\Sigma$), the automaton $\sigma(\mathcal{A})$ (over the alphabet $\Gamma$) is also deterministic. For a nondeterministic automaton $\mathcal{A}$ that satisfies additionally the condition that the state $\emptyset$ is not reachable from the initial state of $\mathcal{A}^{\mathsf{D}}$ (that is, $\mathcal{A}^{\mathsf{D}}$ does not have the state $\emptyset$), we have that $\sigma(\mathcal{A})^{\mathsf{D}}\cong\sigma(\mathcal{A}^{\mathsf{D}})$ (identifying $\bar{q}$ with $\{\bar{q}\}$). So,

[TABLE]

under the previously mentioned condition for $\mathcal{A}^{\mathsf{R}}$, which can be satisfied w.l.o.g. by adding an initial non-final state to $\mathcal{A}^{\mathsf{R}}$ with $a$- and $b$-labeled self-loops (that is, by adding a final non-initial state to $\mathcal{A}$ with $a$- and $b$-labeled self-loops). So, for a nondeterministic automaton $\mathcal{A}$ the claim is:

[TABLE]

The proof of the third equivalence uses the fact that $\sigma(\mathcal{A}^{\mathsf{RD}})$ consists of a single SCC. The left-to-right direction is immediate. For the right-to-left direction, observe that the initial and final state $\bar{q}$ of the DFA $\sigma(\mathcal{A}^{\mathsf{RD}})$ has $a$- and $b$-labeled self-loops, i.e., $\Sigma^{*}\subseteq L(\sigma(\mathcal{A}^{\mathsf{RD}}))$. Thus, for every $n$ there is a word of length $n$ that is accepted from the initial state $\bar{q}$. But $\sigma(\mathcal{A}^{\mathsf{RD}})$ is well-behaved, which implies that all strings of any length must be accepted from $\bar{q}$, i.e., $L(\sigma(\mathcal{A}^{\mathsf{RD}}))=\Gamma^{*}$. So, we have established that the polynomial-time (in fact, log-space) construction $\mathcal{A}\mapsto\rho(\mathcal{A})$ reduces the universality problem for NFAs to Nfa$(\log n)$. ∎