NON-RETURNING DETERMINISTIC AND NONDETERMINISTIC FINITE AUTOMATA WITH TRANSLUCENT LETTERS

. Here, we propose a variant of the nondeterministic finite automaton with translucent letters (NFAwtl), which, after reading and deleting a letter, does not return to the left end of its tape, but instead continues from the position of the letter just deleted. When the end-of-tape marker is reached, our automaton can decide whether to accept, reject, or continue, which means that it reads the remaining tape contents again from the beginning. This type of automaton, called a non-returning finite automaton with translucent letters or an nrNFAwtl , is strictly more expressive than the NFAwtl. We study the expressive capacity of this type of automaton and that of its deterministic variant, comparing them to various other types of finite automata that do not simply read their input from left to right. Also, we are interested in the closure properties of the resulting classes of languages and in the complexity of the fixed membership problem.


Introduction
While a (deterministic or nondeterministic) finite automaton reads its input strictly from left to right, letter by letter, by now, many types of automata have been considered in the literature that process their inputs in a different, more involved way.In this aspect, the most extreme is the jumping finite automaton of Meduna and Zemek [11] (see also [8]), which, after reading a letter, jumps to an arbitrary position of the remaining input.It is known that the jumping finite automaton accepts languages that are not even context-free, like the language { w ∈ {a, b, c} * | |w| a = |w| b = |w| c }, but at the same time, it does not even accept the finite language {ab}.
Another example is the nondeterministic linear automaton (or NLA) studied by Loukanova in [10], which is a nondeterministic finite automaton with two heads, one reading the input from left to right, the other reading the input from right to left.This model can be simulated by a model with one head that reads the first and the last letter alternatingly.It is easily seen that this model characterizes the class LIN of linear context-free languages.Actually, the NLA corresponds to the 5 ′ → 3 ′ -sensing Watson-Crick automaton defined by Nagy in [15].
Moreover, there is the restarting automaton as introduced by Jančar, Mráz, Plátek, and Vogel in [9], which processes a given input in cycles, in each cycle scanning the remaining input from left to right until it deletes one or more letters, returns its read/write window to the left end of the remaining input, and reenters its initial state.When using a window of size larger than one, these so-called R-automata accept a proper superclass of the regular languages that is incomparable to the context-free and the growing context-sensitive languages (see, e.g., [22]), while with a window of size one, they accept exactly the regular languages [12].
Finally, there is the (deterministic and nondeterministic) finite automaton with translucent letters (or DFAwtl and NFAwtl) of Nagy and Otto [18], which is equivalent to a cooperating distributed system of stateless deterministic R-automata with windows of size one.For each state q of an NFAwtl, there is a set τ (q) of translucent letters, which is a subset of the input alphabet containing those letters that the automaton cannot see when it is in state q.Accordingly, in each step, the NFAwtl just reads (and deletes) the first letter from the left, which it can see, that is, the first letter that is not translucent in its current state.It has been proved that the NFAwtl accepts a class of semi-linear languages that properly contains all rational trace languages, while its deterministic variant, the DFAwtl, is properly less expressive.In fact, the DFAwtl just accepts a class of languages that is incomparable to the rational trace languages with respect to inclusion [17,[19][20][21].In addition, while the obvious upper bound for the time complexity of the membership problem for a DFAwtl is DTIME(n 2 ), a better upper bound of DTIME(n • log n) is derived in [16].
Here, we propose a variant of the nondeterministic finite automaton with translucent letters, which, after reading and deleting a letter, does not return its head to the left end of its tape, but instead continues from the position of the letter just deleted.When the end-of-tape marker is reached, our automaton can decide whether to accept, reject, or continue, which means that it reads the remaining tape contents again from the beginning.We prove that this type of automaton, called a non-returning finite automaton with translucent letters or an nrNFAwtl, is strictly more expressive than the NFAwtl.However, as we shall see, its deterministic variant, the nrDFAwtl, which is more expressive than the DFAwtl, is still not powerful enough to accept all rational trace languages.In this paper, we concentrate on the problem of determining just how expressive these types of automata are and on the complexity of their fixed membership problem, but we are also interested in the closure and non-closure properties of the resulting classes of languages.
This paper is structured as follows.In Section 2, we present the formal definition of the non-returning finite automaton with translucent letters, explain its workings by a detailed example, and derive a kind of normalized form for this type of automaton.In the next section, we compare the classes of languages accepted by the nondeterministic and the deterministic non-returning finite automaton with translucent letters to the language classes accepted by the DFAwtl and the NFAwtl and to the rational trace languages, establishing some proper inclusion results and some incomparability results.Also, we present a few closure and non-closure properties for the classes of languages that are accepted by the nondeterministic and the deterministic non-returning finite automaton with translucent letters.Then, in Section 4, we compare the non-returning finite automaton with translucent letters to the jumping finite automaton, the right one-way jumping finite automaton of [2,5], and the right-revolving finite automaton of [3], deriving the complete taxonomy of the resulting classes of languages.As it turns out, the non-returning DFAwtl can be seen as an extension of the right one-way jumping finite automaton that can detect the end of its input.Finally, in Section 5, we study the complexity of the fixed membership problem for the nrDFAwtl, showing that it is decidable in time O(n • (log n) 2 ) whether a word of length n is accepted by a given nrDFAwtl.In the final section, we summarize our results and state a number of open problems for future work.

Definitions
Throughout the paper, λ denotes the empty word, and the concatenation of two words u and v over an alphabet Σ is denoted by u • v or simply by uv.
The nondeterministic finite automaton with translucent letters was introduced in [18].It is defined as follows.
Definition 2.1.A finite automaton with translucent letters, an NFAwtl for short, is defined as a 7-tuple A = (Q, Σ, ¡, τ, I, F, δ), where Q is a finite set of internal states, Σ is a finite alphabet of input letters, ¡ ̸ ∈ Σ is a special symbol that is used as an end-of-tape marker, τ : Q → P(Σ) is a translucency mapping, I ⊆ Q is a set of initial states, F ⊆ Q is a set of final states, and δ : Q × Σ → P(Q) is a transition relation.Here, it is required that, for each state q ∈ Q and each letter a ∈ Σ, if a ∈ τ (q), then δ(q, a) = ∅.For each state q ∈ Q, the letters from the set τ (q) are translucent for q, that is, in state q, the automaton A does not see these letters.
An NFAwtl A = (Q, Σ, ¡, τ, I, F, δ) works as follows.For an input word w ∈ Σ * , it starts in a nondeterministically chosen initial state q 0 ∈ I with the word w • ¡ on its tape.Assume that w = a 1 a 2 • • • a n for some n ≥ 1 and a 1 , a 2 , . . ., a n ∈ Σ, and assume that A is in state q ∈ Q.Then A looks for the first occurrence from the left of a letter that is not translucent for state q, that is, if w = uav such that u ∈ (τ (q)) * , v ∈ Σ * , and a ∈ (Σ ∖ τ (q)), then A nondeterministically chooses a state q 1 ∈ δ(q, a), erases the letter a from the tape, thus producing the tape contents uv • ¡, its internal state is set to q 1 , the head returns to the first letter on the tape, and the computation continues.In case δ(q, a) = ∅, A halts without accepting.Finally, if w ∈ (τ (q)) * , then A sees the end-of-tape marker ¡ and the computation halts.In this case, A accepts if q is a final state; otherwise, it does not accept.Thus, A executes the following computation relation on its set Q • Σ * • {¡} ∪ {Accept, Reject} of configurations, where u, v, w are words over Σ and a is a letter from Σ: and q ′ ∈ δ(q, a), Reject, if w = uav, u ∈ (τ (q)) * , a ̸ ∈ τ (q), and δ(q, a) = ∅, Accept, if w ∈ (τ (q)) * and q ∈ F, Reject, if w ∈ (τ (q)) * and q ̸ ∈ F.
Observe that this definition also applies to configurations of the form q • ¡, that is, q • λ • ¡ ⊢ A Accept holds if and only if q is a final state.A word w ∈ Σ * is accepted by A if there exists an initial state q 0 ∈ I such that q 0 w • ¡ ⊢ * A Accept, where ⊢ * A denotes the reflexive and transitive closure of the single-step computation relation ⊢ A .Now L(A) = { w ∈ Σ * | w is accepted by A } is the language accepted by A and L(NFAwtl) denotes the class of all languages that are accepted by NFAwtls.Definition 2.2.An NFAwtl A = (Q, Σ, ¡, τ, I, F, δ) is a deterministic finite automaton with translucent letters, abbreviated as DFAwtl, if |I| = 1 and if |δ(q, a)| ≤ 1 for all q ∈ Q and all a ∈ Σ.Then L(DFAwtl) denotes the class of all languages that are accepted by DFAwtls.
To emphasize the distinction between deterministic and nondeterministic finite automata with translucent letters, if an NFAwtl A = (Q, Σ, ¡, τ, I, F, δ) with I = {q 0 } is a DFAwtl, then we denote it simply as A = (Q, Σ, ¡, τ, q 0 , F, δ).In addition, for any states q, q ′ ∈ Q and any letter a ∈ Σ, we write δ(q, a) = q ′ instead of δ(q, a) = {q ′ } and we say that δ(q, a) is undefined if δ(q, a) = ∅.For future reference, we present an example of a DFAwtl.
and the functions τ and δ that are defined as follows: and δ is undefined for all other pairs from Q × Σ.For the word abba ′ b ′ ab ′ a ′ , the DFAwtl A c executes the following accepting computation: In fact, if φ denotes the morphism that is defined through φ(a) = a ′ and φ(b) = b ′ , then it is easily checked that L(A c ) = w∈{a,b} * sh(w, φ(w)), where sh denotes the shuffle operation defined for any pair of words u, v over an alphabet Σ as The above language L(A c ) is not context-free.In fact, it is not even a growing context-sensitive language.Let π : {a, b, a ′ , b ′ } * → {a, b} * be the morphism that is defined through a → a, b → b, a ′ → a, and b ′ → b.Then which is the copy language on {a, b} * that is not growing context-sensitive [4].As the class GCSL of growing context-sensitive languages is closed under the operations of intersection with regular sets and non-erasing morphisms, this implies that the language L(A c ) is not growing context-sensitive, either.Thus, Example 2.3 shows that DFAwtls already accept some quite complicated languages in comparison to the Chomsky hierarchy.
Recall that a language L ⊆ Σ * is a rational trace language if there exist a dependency relation D on Σ and a regular language R ⊆ Σ * such that L coincides with the closure of R under the partial commutativity relation ≡ D induced by D (see, e.g., [7]).Here, a dependency relation is a binary relation on Σ that is reflexive and symmetric, and the partial commutativity relation ≡ D is the congruence on Σ * that is induced by the pairs It is easily seen that the language L(A c ) is the rational trace language that is obtained from the regular language {aa ′ , bb ′ } * through the above dependency relation D [17,20].Hence, we obtain the following non-inclusion result.
Theorem 2.4.The class LRAT of rational trace languages is not contained in the language class GCSL.
The NFAwtl is equivalent to cooperating distributed systems of a very restricted type of deterministic restarting automata of window size one [18].From this equivalence, it follows that the NFAwtls accept a class of semi-linear languages that properly contains the class of all rational trace languages.At the same time, DFAwtls are less expressive, as they just accept a class of languages that is incomparable to the rational trace languages with respect to inclusion [17,[19][20][21].Furthermore, while the obvious upper bound for the time complexity of the fixed membership problem for a DFAwtl is DTIME(n 2 ), a better upper bound of DTIME(n • log n) is derived in [16], and a corresponding result holds for the nondeterministic case.
As defined above, an NFAwtl performs each step of its computation starting from the first letter on its tape: it looks for the first letter that is not translucent in its current state, deletes it and returns to the first letter.Here, we propose a variant of this type of automaton that does not return to the first letter, but continues from the position of the deleted letter, returning to the first letter only after the tape content has been read completely.Next, we present the formal definition of this type of automaton, which is called the non-returning finite automaton with translucent letters or nrNFAwtl for short.Definition 2.5.An nrNFAwtl is defined by a 6-tuple A = (Q, Σ, ¡, τ, I, δ), where Q is a finite set of internal states, Σ is a finite alphabet of input letters, ¡ ̸ ∈ Σ is a special symbol that is used as an end-of-tape marker, τ : Q → P(Σ) is a translucency mapping, I ⊆ Q is a set of initial states, and is a transition relation.Here it is required that, for each state q ∈ Q and each letter a ∈ Σ, δ(q, a) ⊆ Q, and if a ∈ τ (q), then δ(q, a) = ∅.For each state q ∈ Q, the letters from the set τ (q) are translucent for q, that is, in state q, the automaton A does not see these letters.
Similarly as for a DFAwtl, if A = (Q, Σ, ¡, τ, I, δ) is an nrNFAwtl that is deterministic, then we write A = (Q, Σ, ¡, τ, q 0 , δ), where q 0 is the only initial state of A, and, for any states q, q ′ and any letter a, we write δ(q, a) = q ′ instead of δ(q, a) = {q ′ } and say that δ(q, a) is undefined if δ(q, a) = ∅, From the above definition, we see that δ(q, ¡) is either a subset of Q or the operation Accept, that is, when seeing the end-of-tape marker ¡ in state q, the nrNFAwtl A has either the option to change its state or to accept.The nrNFAwtl A = (Q, Σ, ¡, τ, I, δ) works as follows.For an input word w ∈ Σ * , A starts in a nondeterministically chosen initial state q 0 ∈ I with the word w • ¡ on its tape.This situation is described by the configuration q 0 w • ¡.Now assume that A is in a configuration of the form xq 1 w • ¡, where q 1 ∈ Q and x, w ∈ Σ * , that is, A is in state q 1 , the tape contains the word xw • ¡, and the head of A is on the first letter of the suffix w • ¡.Then A looks for the first occurrence from the left of a letter in w that is not translucent for state q 1 , that is, if w = uav such that u ∈ (τ (q 1 )) * , v ∈ Σ * , and a ∈ (Σ ∖ τ (q 1 )), then A nondeterministically chooses a state q 2 ∈ δ(q 1 , a), erases the letter a from the tape, thus producing the tape contents xuv • ¡, sets its internal state to q 2 , and continues the computation from the configuration xuq 2 v • ¡.In case δ(q 1 , a) = ∅, A halts without accepting.Finally, if w ∈ (τ (q 1 )) * , then A reaches the end-of-tape marker ¡ and a transition from the set δ(q 1 , ¡) is applied.This transition is either an accept step or a state q 2 from Q.In the former case, A halts and accepts, while in the latter case, it continues the computation in state q 2 by reading its tape again from left to right, that is, from the configuration q 2 xw • ¡.Finally, if δ(q 1 , ¡) is undefined, then A halts and rejects.Thus, the computation relation A of the single-step computation relation ⊢ A that is specified as follows, where x, u, v, w are words from Σ * and a is a letter from Σ: ) * , a ̸ ∈ τ (q), and q ′ ∈ δ(q, a), Reject, if w = uav, u ∈ (τ (q)) * , a ̸ ∈ τ (q), and δ(q, a) = ∅, q ′ xw • ¡, if w ∈ (τ (q)) * and q ′ ∈ δ(q, ¡), Accept, if w ∈ (τ (q)) * and δ(q, ¡) = Accept, Reject, if w ∈ (τ (q)) * and δ(q, ¡) = ∅.
To describe computations of nrNFAwtls in a compact way, we introduce the notions of a sweep and a cycle.
(a) A sweep is a part of a computation of A in which the head moves from left to right across the complete tape contents.Thus, a sweep has the form q 1 wu • ¡ ⊢ * A w ′ q 2 u • ¡, where q 1 , q 2 ∈ Q, u ∈ (τ (q 2 )) * , the word w ′ is obtained from w by deleting some letters or w = w ′ = λ and q 1 = q 2 , and the end-of-tape marker ¡ is not visited during this partial computation.We use the notation to denote the above sweep.Observe that the configurations w ′ q 2 u • ¡ and w ′ uq 2 • ¡ have exactly the same immediate successor configurations, as the word u only contains letters that are translucent for the state q 2 .(b) A cycle is a part of a computation of A that consists of a sweep q 1 wu • ¡ ⊢ s A w ′ uq 2 • ¡ together with the next transitional step q 3 ∈ δ(q 2 , ¡).Thus, a cycle has the form We use the notation A word w ∈ Σ * is accepted by the nrNFAwtl A = (Q, Σ, ¡, τ, I, δ) if there exists an initial state q 0 ∈ I such that A has an accepting computation of the form q 0 w • ¡ ⊢ * A Accept.Then is the language accepted by A. We use L(nrNFAwtl) to denote the class of languages that are accepted by nrNFAwtls and L(nrDFAwtl) to denote the class of languages that are accepted by nrDFAwtls.We illustrate these definitions by an example.
As defined above, an nrNFAwtl A = (Q, Σ, ¡, τ, I, δ) may run into an infinite computation.Just assume that q is a state of A, w ∈ (τ (q)) * , and q ∈ δ(q, ¡).Then qw • ¡ ⊢ A qw • ¡ ⊢ A qw • ¡, and so forth.However, we can avoid this by converting A into an equivalent nrNFAwtl B as follows.
for all q ∈ Q, S ⊆ Q, and all a ∈ Σ, and δ ′ ((q, S), ¡) = { (p, S ∪ {q}) | p ∈ δ(q, ¡) and q ̸ ∈ S } for all q ∈ Q and all S ⊆ Q.Finally, take δ ′ ((q, S), ¡) = Accept if δ(q, ¡) = Accept.The set S is used to record those states in which the end-of-tape marker has been reached and the computation has continued.In the next cycle, when a non-translucent letter is read, then this set is emptied, otherwise, the next state is added to it.This process continues until either a letter is read and deleted, or until no new state can be added to the current set S, in which case the computation fails.We illustrate this construction through a simple example.
Moreover, an nrNFAwtl A = (Q, Σ, ¡, τ, I, δ) may accept without having read and deleted its input completely.This happens for the automata in Example 2.8, as τ (p) = τ (r) = {a}, r ∈ δ(p, ¡), and δ(r, ¡) = Accept.However, we can easily extend the nrNFAwtl A into an equivalent nrNFAwtl C that always reads and deletes its input completely before it accepts.Just take C = (Q ∪ {q e }, Σ, ¡, τ ′ , I, δ ′ ), where q e is a new state, τ ′ (q) = τ (q) for all q ∈ Q and τ ′ (q e ) = ∅, and δ ′ is defined as follows: = δ(q, a) for all q ∈ Q and all a ∈ Σ, Given a word w ∈ Σ * as input, the nrNFAwtl C will execute exactly the same steps as the nrNFAwtl A until A accepts.Now, the accept step of A is simulated by C through changing into state q e .As τ ′ (q e ) = ∅ and as δ ′ (q e , a) = {q e } for all a ∈ Σ, C will now read and delete the remaining tape contents and accept on reaching the end-of-tape marker ¡.It easily follows that L(C) = L(A).Together, the two constructions considered above yield the following technical result.Lemma 2.9.Each nrNFAwtl A can be effectively converted into an equivalent nrNFAwtl C that never gets into an infinite computation and that accepts only after reading and deleting its input completely.In addition, if A is deterministic, then so is C.
Hence, in what follows, we can always assume that an nrNFAwtl or an nrDFAwtl considered has the additional properties guaranteed by this lemma.

Some inclusion results and closure properties
Next, we show that the nrNFAwtl is indeed an extension of the NFAwtl.Theorem 3.1.From a given NFAwtl A, one can effectively construct an nrNFAwtl B such that L(B) = L(A).In addition, if A is deterministic, then so is B.
It remains to verify that B just simulates the computations of A.
Assume that qw • ¡ is a configuration of A, that is, q ∈ Q and w ∈ Σ * .From the definition of the computation relation ⊢ A , we see that there are four different cases that we must consider.
In this case, B can execute the following sequence of steps: On the other hand, if δ(q, a) = ∅, then A halts and rejects.However, in this case, also δ B (q, a) = ∅, and hence, B halts and rejects as well.
If q ∈ F , then A accepts.In this case, δ B (q, ¡) = Accept, that is, B halts and accepts, too.If q ̸ ∈ F , then A rejects.In this case, δ B (q, ¡) = ∅, that is, B halts and rejects as well.

It follows that L(A) ⊆ L(B).
Conversely, if w ∈ L(B), then it is easily verified that each accepting computation of B on input w is just a simulation of an accepting computation of A on input w.Thus, we see that L(B) = L(A).
Finally, the above definition of B shows that B is deterministic, if A is.This completes the proof of Theorem 3.1.
Together with Example 2.7, this theorem has the following consequence.
It is known that all languages accepted by NFAwtls are necessarily semi-linear, that is, their images with respect to the Parikh mapping are semi-linear subsets of N m , where N is the set of nonnegative integers and m is the cardinality of the alphabet used.Does a corresponding result also hold for nrNFAwtls?First, we consider this question for the special case of a unary alphabet.Proposition 3.3.A language L ⊆ {a} * is accepted by an nrNFAwtl if and only if it is a regular language.
Proof.If L ⊆ {a} * is a regular language, then it is obviously accepted by an nrNFAwtl.
Conversely, assume that an nrNFAwtl A = (Q, {a}, ¡, τ, I, δ) accepts a language L ⊆ {a} * .By Lemma 2.9, we can assume that the nrNFAwtl A never gets into an infinite computation and that it accepts only after reading and deleting its input completely.From A, we now construct an NFA with λ-transitions B = (Q, {a}, I, F, δ B ) by taking F = { q ∈ Q | δ(q, ¡) = Accept } and by defining the transition relation δ B as follows: (1) δ B (q, a) = δ(q, a) We claim that L(B) = L(A) = L holds, which then implies that L is a regular language.
For each state q ∈ Q, if τ (q) ̸ = ∅, then τ (q) = {a} and δ(q, a) = ∅.Hence, for all m ≥ 1, On the other hand, for each state q ∈ Q for which τ (q) = ∅, Hence, if a m is accepted by the nrNFAwtl A, then a corresponding accepting computation of A reads (and deletes) the word a m simply letter by letter from left to right, where this sequence of computational steps may be interspersed with steps that change the state without reading (and deleting) an occurrence of the letter a.Now, it is easily seen that the NFA B can execute the very same computation.Conversely, each accepting computation of the NFA B just mirrors an accepting computation of the nrNFAwtl A. This completes the proof of Proposition 3.3.
Thus, all unary languages that are accepted by nrNFAwtls are semi-linear.For non-unary alphabets, the corresponding question is still open.To illustrate this problem, we consider the following detailed example.
(3) δ(q 2 , a) = q 3 , (6) δ(q 4 , a) = q 5 , (9) δ(q 6 , ¡) = q 0 , We can actually describe the nrDFAwtl A ex3 through the diagram given in Figure 1.In this diagram, the vertices correspond to the states of A, an edge of the form q i x / / q j denotes a transition from q i to q j that simply reads an occurrence of the letter x, and an edge of the form q i (Y * ,x) / / q j denotes a transition from q i to q j in which a factor from Y * is skipped and a subsequent occurrence of the letter x is read.Finally, an edge, the label of which contains the end-of-tape marker ¡, corresponds to starting a new sweep or an accept operation.
From this diagram, we can easily extract the following information on the computations of A ex3 : 1.The shortest path from q 0 to Accept removes a single occurrence of each of the letters a, b, and c.

A sweep of the automaton
A starts in q 0 and ends in q 2 or in q 6 , or it starts in q 7 .3. A sweep may contain one or more repetitions of the cycle q 6 → q 1 → q 2 → q 3 → q 4 → q 5 → q 6 , during which two occurrences of each of the letters a, b, and c are removed.4.During a sweep that ends at q 6 , the same even number of occurrences of each of the letters a, b, and c are removed.5.The last part of an accepting computation leads from q 0 or from q 6 to q 1 , then to q 2 , then to q 7 , and finally to q 8 .Thus, during this part, a single occurrence of each of the letters a, b, and c is removed.We now consider an input of the form (abc) 3n for some n ≥ 2. We shall see that q 0 (abc) 3n • ¡ ⊢ * Aex3 q 0 (abc) n • ¡ holds.To prove this statement, we first establish the following technical results.
Proof.(a) For n ≥ 1, we obtain the following initial part of a computation of A ex3 on input (abc) n : which proves the statement in (a).
(b) For all k ≥ 0 and m ≥ 3, we have the following partial computation of A ex3 : which proves (b).
(c) Finally, for n ≥ 1, we have the following partial computation of A ex3 : By putting these partial computations together, we obtain the following computation for all n ≥ 2 and all 1 ≤ k ≤ n − 1: In addition, Hence, it follows that L ex3 = { (abc) Unfortunately, A ex3 also accepts some words that do not belong to the language L ex3 .In fact, it can be shown that ).Indeed, for n = 0, we have ab(cacabb) n c = abc ∈ L(A ex3 ).Now, proceeding by induction on n, As π(ab(cacabb) n c) = (2n + 1, 2n + 1, 2n + 1), we see that which shows that the language L(A ex3 ) is in fact semi-linear.
On the other hand, we have the following fact.
Proof.If w = (abc) 3n+1 , then and from the configuration q 7 (abc) n a • ¡, A ex3 accepts only if n = 0. Analogously, if w = (abc) 3n+2 , then Therefore, the only powers of abc that A ex3 accepts are those of the form (abc) m for which m is a power of three.
Our example shows that the intersection of a language that is accepted by an nrDFAwtl with a regular set is not necessarily semi-linear.
At this point, it remains open whether the class L(nrDFAwtl) contains any non-unary languages that are not semi-linear.
As all rational trace languages are accepted by NFAwtls, Corollary 3.2 implies that all rational trace languages are accepted by nrNFAwtls.However, as shown in [21], the rational trace language is not accepted by any DFAwtl.Our next result shows that this language is not even accepted by any nrDFAwtl.Proof.Assume that A = (Q, Σ, ¡, τ, I, δ) is an nrDFAwtl that accepts the language L ∨ , where Q = {q 0 , q 1 , . . ., q m−1 }, Σ = {a, b}, and I = {q 0 }.
Proof.As L(A) = L ∨ , and as an nrDFAwtl only deletes letters during its computation, we see that w = a r b s is converted into a r−r1 b s−s1 for some 0 ≤ r 1 ≤ r and 0 ≤ s 1 ≤ s.Thus, during the above sweep, A first reads (and deletes) r 1 occurrences of the letter a, and then it reads (and deletes) s 1 occurrences of the letter b.If r 1 > m, then some state of A appears at least twice while the head of A is still inside the prefix a r .This implies that by using pumping, A can also execute the sweeps of the form for all µ ≥ 1 and some value 1 ≤ t ≤ m.But then, together with a n b n or a n b 2n , A would also accept the words a n+µ•t b n or a n+µ•t b 2n , a contradiction.It follows that r 1 ≤ m, and analogously, it can be shown that s 1 ≤ m.
Let n > 3m 2 .By Lemma 2.9, we can assume that A reads and deletes its input completely before it accepts.As a n b n ∈ L ∨ , the computation of A on input a n b n is accepting.It consists of a sequence of sweeps and an accept step, that is, we have where k ≥ 1 and r i , s i ≤ m for all i = 1, 2, . . ., k.Furthermore, since A accepts only after completely deleting its input, we have As A has only m states, it follows that there are indices 1 ≤ α < β ≤ m + 1 such that the states q jα and q j β are identical.Therefore, the above computation can be written as follows: To simplify the notation, we take Then we also have the following accepting computation: Thus, a n+c b n+c ′ ∈ L ∨ .As c ≤ m 2 and c ′ ≤ m 2 , while n > 3m 2 , it follows that n + c = n + c ′ , which in turn implies that c = c ′ .Now we consider the accepting computation of A for the input a n b 2n ∈ L ∨ .As A is deterministic, this computation looks as follows: However, A can then also execute the following accepting computation: Thus, a n+c b 2n+c ∈ L ∨ .However, n + c < 2n + c < 2(n + c), which shows that a n+c b 2n+c ̸ ∈ L ∨ , a contradiction.Hence, it follows that L ∨ is not accepted by any nrDFAwtl.
As L ∨ is a rational trace language, the above result implies that the class of rational trace languages is not even contained in the language class L(nrDFAwtl).
Finally, we present some closure and non-closure properties for the classes of languages that are accepted by nrNFAwtls and by nrDFAwtls.
Theorem 3.6.The language class L(nrNFAwtl) is closed under union and disjoint shuffle.
for the shuffle language sh(L 1 , L 2 ) by taking and Given a word w ∈ (Σ 1 ∪ Σ 2 ) * as input, A starts in a state from I 1 , and it behaves just like the automaton A 1 , ignoring all letters from Σ 2 .If and when the end-of-tape marker ¡ is reached in a state q ∈ Q 1 for which δ 1 (q, ¡) = Accept holds, then A enters a state from the set I 2 and continues its computation by simulating A 2 , this time ignoring all letters from Σ 1 that may still be on its tape.Finally, A accepts if and when the computation of A 2 accepts.It follows that L(A) = sh(L(A 1 ), L(A 2 )) = sh(L 1 , L 2 ).Thus, the class L(nrNFAwtl) is closed under disjoint shuffle.
For nrDFAwtls, we have the following results.Next, we prove that the class L(nrDFAwtl) is closed under complementation.Let A = (Q, Σ, ¡, τ, I, δ) be an nrDFAwtl such that L(A) = L ⊆ Σ * .Recall from Lemma 2.9 that we can assume that all computations of A are finite.We define an nrDFAwtl A c = (Q ∪ {q + }, Σ, ¡, τ c , I, δ c ), where q + is a new state, by taking Given a word w ∈ Σ * as input, the automaton A c simulates the computation of the automaton A on input w step by step until A either accepts or gets stuck.In the former case, A c reaches the end-of-tape marker ¡ and gets stuck, while in the latter case, it enters the state q + and accepts.It follows that L(A c ) = Σ * ∖ L(A), which shows that the class L(nrDFAwtl) is closed under complementation.
Closure under complementation and non-closure under union imply that the class L(nrDFAwtl) is not closed under intersection.Furthermore, closure under disjoint shuffle is proved in the same way as for nrNFAwtls.
Finally, let Σ = {a, b, c}, let and let φ : Σ * → {a, b} * be the alphabetic morphism that is defined through a → a, b → b, and c → b.It is easily verified that the language L is accepted by a DFAwtl.However, φ(L) = L ∨ , which is not accepted by any nrDFAwtl by Proposition 3.5.This proves that the class L(nrDFAwtl) is not closed under alphabetic morphisms.
As we shall see later, using another example language (see Cor. 4.20), the class L(nrNFAwtl) is not closed under alphabetic morphisms, either.However, many questions concerning closure and non-closure are still open for non-returning finite automata with translucent letters.

Comparing finite automata with translucent letters to various types of jumping finite automata
As it will serve as a reference, we restate, in short, the definition of the finite automaton.
Definition 4.1.A nondeterministic finite automaton, or an NFA, is given through a 5-tuple A = (Q, Σ, I, F, δ), where Q is a finite set of states, Σ is a finite alphabet, I, F ⊆ Q are the sets of initial and final states, respectively, and δ : Here, q is the current state, and w is the still unread part of the input.A configuration of the form q 0 w is called an initial configuration, if q 0 ∈ I.The computation relation ⊢ * A that A induces on its set of configurations is the reflexive and transitive closure of the single-step computation relation ⊢ A that is defined as follows: qw ⊢ q ′ w ′ if w = aw ′ for some a ∈ Σ, w ′ ∈ Σ * , and q ′ ∈ δ(q, a).
A q f } is the language accepted by the NFA A. Observe that an NFA A reads its input strictly from left to right, letter by letter.It is well-known that the language class L(NFA) of languages that are accepted by NFAs is the class REG of regular languages, and that this class coincides with the class L(DFA) of languages that are accepted by DFAs.Next, we recall the definition of the jumping finite automaton from [11].Definition 4.2.A jumping finite automaton, or a JFA, is given through a 5-tuple J = (Q, Σ, I, F, δ), where all components are defined as for an NFA.However, the computation relation of J is defined very differently.
A configuration of J is any word uqv from the set Σ * • Q • Σ * .The computation relation ↷ * J that J induces on its set of configurations is the reflexive and transitive closure of the single-step jumping relation ↷ J that is defined as follows, where q, q ′ ∈ Q, x, z, x ′ , z ′ ∈ Σ * , and a ∈ Σ: that is, when reading the letter a in state q, then J consumes that letter, changes to state q ′ , and moves its head to an arbitrary letter of the remaining tape inscription.Consequently, is the language accepted by the JFA J.
It has been observed that the JFA accepts some languages that are not even context-free, e.g., the language while, on the other hand, it does not even accept the finite language L f = {ab}.Thus, the class L(JFA) of languages that are accepted by jumping finite automata is incomparable under inclusion to the finite languages, the regular languages, and the (deterministic) context-free languages.In fact, the following characterization has been established for this language class.

Theorem 4.3. [5]
A language L is accepted by a JFA if and only if L is commutative and semi-linear.
Here, a language L is called commutative if it is closed under commutation, that is, if w ∈ L, then also each permutation of w is in L. Thus, a language L is accepted by a jumping finite automaton if and only if it is the commutative closure of a regular language.In particular, this shows that these languages are rational trace languages, that is, we have the following proper inclusion.By Proposition 3.5, the language L ∨ is not accepted by any nrDFAwtl.However, this language is the commutative closure of the regular language hence, it is accepted by a jumping finite automaton.This yields the following incomparability results.
Corollary 4.5.The language class L(JFA) is incomparable under inclusion to the language classes L(DFAwtl) and L(nrDFAwtl).
However, it remains open whether L(JFA) is contained in the class GCSL of growing context-sensitive languages, or whether there is a language that is accepted by a jumping finite automaton but that is not growing context-sensitive.
Next, we turn to a restricted class of jumping finite automata, the so-called right one-way jumping finite automaton.
Definition 4.6.[2, 5] A nondeterministic right one-way jumping finite automaton, or an NROWJFA, is given through a 5-tuple J = (Q, Σ, I, F, δ), where Q is a finite set of states, Σ is a finite alphabet, I ⊆ Q is the set of initial states, F ⊆ Q is the set of final states, and δ : Q × Σ → P(Q) is a transition relation.For each state q ∈ Q, Σ q = { a ∈ Σ | δ(q, a) ̸ = ∅ } is the set of letters that J can read in state q.
A configuration of the NROWJFA J is a word qw from the set Q • Σ * .The computation relation ⟳ * J that J induces on its set of configurations is the reflexive and transitive closure of the right one-way jumping relation ⟳ J that is defined as follows, where q, q ′ ∈ Q, x, y ∈ Σ * , and a ∈ Σ: qxay ⟳ J q ′ yx if x ∈ (Σ ∖ Σ q ) * and q ′ ∈ δ(q, a).Thus, being in state q, J reads and deletes the first letter to the right of the actual head position that it can actually read in that state, while the prefix that consists of letters for which J has no transitions in the current state is cyclically shifted to the end of the current tape contents.Then is the language accepted by the NROWJFA J.
The NROWJFA J is deterministic, that is, a right one-way jumping finite automaton or a ROWJFA, if |I| = 1 and |δ(q, a)| ≤ 1 for all q ∈ Q and a ∈ Σ.
For a ROWJFA, we again use the notation J = (Q, Σ, q 0 , F, δ), where q 0 is the only initial state of J and δ : Q × Σ → Q is the transition function, that is, we write δ(q, a) = q ′ instead of δ(q, a) = {q ′ }.
In [2], Beier and Holzer also consider nondeterministic right one-way jumping finite automata with λtransitions, that is, these automata can perform a change of state without reading an input letter.Actually, they study three different types of these automata based on the conditions that enable the execution of λtransitions.However, as finite automata with translucent letters that have λ-transitions have not been defined and investigated yet, we do not consider these types of nondeterministic right one-way jumping automata here.Now, we illustrate the workings of a (N)ROWJFA with some simple examples taken from [2] and [5].
Example 4.9.Let J = ({p 0 , q 0 , q 1 }, {a, b}, {p 0 , q 0 }, {p 0 , q 0 }, δ) be the NROWJFA that is specified by the following transition relation: Starting from state p 0 , J accepts on input w ∈ {a, b} * iff |w| b = 0, while starting from state q 0 , J accepts on input w ∈ {a, b} It has been shown that the language { a n b n | n ≥ 0 } is not accepted by any NROWJFA [1].Furthermore, the permutation-closed language is accepted by a JFA according to Theorem 4.3, but it is not accepted by an ROWJFA [1].Together with Example 4.8, this shows that the language classes L(ROWJFA) and L(JFA) are incomparable under inclusion.Furthermore, as L ′ ∨ is accepted by the NROWJFA from Example 4.9, we have the following proper inclusion result.

Corollary 4.10. L(ROWJFA) ⊊ L(NROWJFA).
It is shown in [2] that the language class L(JFA) coincides with the class of permutation-closed languages that are accepted by NROWJFAs.As already L(ROWJFA) contains all regular languages, this implies that L(JFA) is a proper subclass of L(NROWJFA).Also, it is shown in [2] that all languages accepted by NROWJFAs are semi-linear.Furthermore, it has been observed that the language class L(ROWJFA) is not closed under union, union with regular sets, intersection, intersection with regular sets, complementation, reversal, product, Kleene star or Kleene plus, and (λ-free) morphisms [1,5].In addition, we have the following inclusion results.Proof.As the language { a n b n | n ≥ 0 } is accepted by an nrDFAwtl, while it is not even accepted by any NROWJFA, it follows immediately that the inclusions above are proper inclusions.It remains to verify that the above inclusions actually hold, that is, to show that, for each (N)ROWJFA J, there exists an nrD(N)FAwtl A such that L(A) = L(J).
Let Q A = { q, q ′ , q | q ∈ Q }, I A = { q ′ | q ∈ I }, and let the translucency mapping τ and the transition relation δ A be defined through = ∅ for all q ∈ Q, δ A (q, a) = δ(q, a) for all q ∈ Q and all a ∈ Σ q , δ A (q, ¡) = {q ′ } for all q ∈ Q, δ A (q ′ , a) = δ(q, a) for all q ∈ Q and all a ∈ Σ q , δ A (q ′ , ¡) = {q} for all q ∈ Q, For each state q of the NROWJFA J, the nrNFAwtl A has three corresponding states: q, q ′ , and q.Here, the states of the form q are used to simulate the corresponding steps of J, while those of the form q ′ are used to check whether the current tape inscription contains only letters that J cannot process in state q.In that case, state q is entered and A accepts if q is a final state of J and if the input has been read (and deleted) completely.Note that the nrNFAwtl A is deterministic, if J is deterministic.
In order to prove that L(A) = L(J), we establish the following two claims.
Claim 1.For all words w, z, t ∈ Σ * such that w = zt and all states q ∈ Q and q f ∈ F , if qw ⟳ * J q f , then Proof.We proceed by induction on the length of the computation of J on input w.So let be a computation of the NROWJFA J on an input w ∈ Σ m starting in a state q 0 .If m = 0, then q 0 = q f and w = λ.In this situation, we have as q 0 ∈ F .Now assume that m ≥ 1, and let us suppose that the claim holds for all computations of J of length less than m.We shall show the claim also holds for all computations of J of length m.Let q 0 w ⟳ J q 1 vu ⟳ m−1 J q f ∈ F , where w = uav, u ∈ (Σ ∖ Σ q0 ) * , and q 1 ∈ δ(q 0 , a).Then u ∈ (τ (q ′ 0 )) * and we have where the word vu is of length m − 1.By applying the induction hypothesis, it follows from q 1 vu ⟳ Let w = zt for some words z, t ∈ Σ * .Then either z = uav 1 and v = v 1 t or u = zt 1 and t = t 1 av.
If z = uav 1 and v = v 1 t, then we have By the induction hypothesis, it follows from q If u = zt 1 and t = t 1 av, then we have as z is a prefix of u ∈ (Σ ∖ Σ q0 ) * = (τ (q 0 )) * .By the induction hypothesis, it follows from q If w ∈ L(J), then q 0 w ⟳ J q f for some states q 0 ∈ I and q f ∈ F .Now, Claim 1 implies that As q ′ 0 ∈ I A , we have w ∈ L(A), which proves that L(J) ⊆ L(A).Claim 2. For all words w, z, t ∈ Σ * such that w = zt and all states q 0 ∈ Q and A qf • ¡, then q 0 w ⟳ * J q f .Proof.We proceed by induction on the length of the input w.So let w = zt and assume that q ′ 0 w • ¡, which yields q 0 = q f .Therefore, q 0 w = q 0 ⟳ * J q f .The case that q ′ 0 w • ¡ ⊢ * A qf • ¡ is just a part of the above computation, that is, the statement of the claim holds for |w| = 0.
Finally, let |w| = m ≥ 1, and let us suppose that the claim is true for all words of length less than m.Then w = uav for some u ∈ (τ (q 0 )) * = (Σ ∖ Σ q0 ) * , v ∈ Σ * , and a letter a ∈ Σ such that q 1 ∈ δ(q 0 , a).There are two cases: As |vu| = m − 1, the induction hypothesis implies that q 1 vu ⟳ * J q f .Thus, q 0 w ⟳ * J q f follows.2. If w = zt and tq 0 z • ¡ ⊢ * A qf • ¡, we have again two cases: either z = uav 1 and v = v 1 t or u = zt 1 and t = t 1 av.
If z = uav 1 and v = v 1 t, then and q 0 w = q 0 zt = q 0 uav 1 t ⟳ J q 1 v 1 tu.By applying the induction hypothesis, it follows from tuq as z is a prefix of u ∈ (Σ ∖ Σ q0 ) * , and q 0 zt = q 0 zt 1 av ⟳ J q 1 vzt 1 .By applying the induction hypothesis, it follows from In both cases, we obtain q 0 w ⟳ * J q f .According to the transition relation δ A , the automaton A can reach an accepting configuration only from a state qf for some q f ∈ F , and such a state can be reached only after all letters of the input have been deleted.If w ∈ L(A), then q ′ 0 w • ¡ ⊢ * A qf • ¡ ⊢ A Accept for some states q ′ 0 ∈ I A and q f ∈ F .Hence, according to Claim 2, it follows that q 0 w ⟳ * J q f and q f is a final state of J.This proves that w ∈ L(J) and L(A) ⊆ L(J).Hence, we see that the inclusions L(NROWJFA) ⊆ L(nrNFAwtl) and L(ROWJFA) ⊆ L(nrDFAwtl) hold.
When looking at the definitions, we see that the ROWJFA differs from the nrDFAwtl in two aspects.The first of these is the partitioning of the alphabet.For each state q of an ROWJFA J, the alphabet of J is split into two disjoint subsets: the set Σ q of letters that J can read in state q, and the remaining letters.For a state p of an nrDFAwtl A, the alphabet of A is split into three disjoint subsets: the set of letters that A can read in state p, the set τ (p) of letters that are translucent for state p, and the set of letters that are neither translucent for state p nor can be read in state p.However, the third type of letters for state p can be avoided by defining, for each letter b of this type, δ A (p, b) = q fail , where q fail is a new state in which A cannot read any letter at all.The second aspect is the fact that an nrDFAwtl has an end-of-tape marker and that, whenever its head reaches this marker, then A can execute an additional change of state.It is actually this feature that allows the nrDFAwtl to accept the language { a n b n | n ≥ 0 }, that is, the increase in expressive capacity from the ROWJFA to the nrDFAwtl is due to this second feature.
It remains to compare the NROWJFA and the ROWJFA to the DFAwtl and to the NFAwtl.According to [2], the language is accepted by a DFAwtl, but it is not accepted by any NROWJFA, which means that L(DFAwtl) is not contained in L(NROWJFA).On the other hand, there it is shown that the language is accepted by an ROWJFA, but not by any NFAwtl.Therefore, we have the following incomparability result.Corollary 4.12.
[2] The language classes L(DFAwtl) and L(NFAwtl) are incomparable under inclusion to the language classes L(ROWJFA) and L(NROWJFA).
Next, we compare the right one-way jumping automaton to the class GCSL of growing context-sensitive languages.
Theorem 4.13.There exists a ROWJFA A such that the language L(A) is not growing context-sensitive.
Proof.Let A = (Q, Σ, q 0 , F, δ) be the ROWJFA that is defined as follows: Proof.By induction on the length of the word w ∈ {a, b} * , we show that q 0 φ(w)w ⟳ * A q 0 , hence, A accepts φ(w)w.
If w = cx for some letter c ∈ {a, b} and a word x ∈ {a, b} * , then and induction shows that q 0 φ(x)x ⟳ * A q 0 ∈ F .Thus, φ(w)w ∈ L(A) follows.Hence, we see that { φ(w)w | w ∈ {a, b} * } ⊆ L(A).Proof.In each accepting computation of the automaton A, the state q 0 alternates with the states q a and q b .That is, after an even number of steps, the automaton is in state q 0 , and after an odd number of steps, the automaton is either in state q a or in state q b .In state q 0 , only an a or a b can be read.From state q a (q b ), a letter a ′ (b ′ ) will take A back to state q 0 , while a letter b ′ (a ′ ) takes A to the trap state q − .As q 0 is the only not introduce these λ-transitions in the first place.Concerning the expressive capacity of right-revolving finite automata, the following results have been obtained.The proof of the inclusion in (a) given in [5] easily extends to the nondeterministic case, that is, we also have L(NROWJFA) ⊆ L(rr-NFA).Below, we present a separating example language (see Cor. 4.19).
It follows from Theorem 4.13 that none of the language classes L(NROWJFA), L(rr-DFA), and L(rr-NFA) is contained in the class GCSL, either.On the other hand, as GCSL contains all context-free languages, the fact that { a n b n | n ≥ 0 } ̸ ∈ L(rr-NFA) implies that the class GCSL is not contained in any of these language classes.Thus, we have the following incomparability result.Next, we introduce the language L cc , which can be seen as a simple variant of the language { φ(w)w | w ∈ {a, b} * } considered above.The language L cc is defined as follows: First, we prove that a deterministic right-revolving finite automaton accepts a certain superset of this language.Proposition 4.17.There exists an rr-DFA A such that Proof.Let A = (Q, Σ, q 0 , F, ∆, δ) be the rr-DFA that is defined as follows: This rr-DFA accepts a word of the form awcawc, where w ∈ {a} * , as follows: On the other hand, it is easily seen that any word of the form a m ca n c, where m ̸ = n, is not accepted by A. Thus, it follows that We now prove that there does not exist any nondeterministic right one-way jumping automaton for the language L cc .Actually, we have the following stronger negative result.Proposition 4.18.There does not exist any nrNFAwtl C such that We derive a contradiction by analyzing accepting computations of C on inputs of the form w m = a m ca m c ∈ L cc , where m ≥ 1.
Let m ≥ 1 be a (sufficiently) large integer.As w m = a m ca m c ∈ L cc , the nrNFAwtl C has an accepting computation for the input w m , which looks as follows, where q 0 ∈ I: where q + ∈ Q and δ(q + , ¡) = Accept.Recall from Lemma 2.9 that we may assume without loss of generality that C only accepts once it has read (and deleted) the given input completely.
We can assume that the above computation begins with a sequence of r ≥ 0 steps in which occurrences of the letter a are read: where q 1 , q 2 , . . ., q r ∈ Q.If r ≥ |Q|, then there are indices i, j, 0 ≤ i < j ≤ r, such that q i = q j .In this case, the above computation looks as follows: However, C can then also execute the following computation: a contradiction.Thus, r < |Q| follows, which in turn implies that a ∈ τ (q r ).
If c ∈ τ (q r ), then C has to apply a transition q ′ ∈ δ(q r , ¡) in the configuration q r a m−r ca m c • ¡, which yields the configuration q ′ a m−r ca m c • ¡.Now, further occurrences of the letter a could be read, but the pumping argument above shows that the number of these steps is smaller than |Q| − r.Hence, we finally obtain a configuration of the form qa s ca m c • ¡, where s ≤ m and q ∈ Q such that a ∈ τ (q), but c ̸ ∈ τ (q).Then, the above computation continues as follows, where q ′ ∈ δ(q, c): Next, t occurrences of the letter a may be deleted from the factor a m , but by using the same pumping argument as above, it follows that the number t is bounded from above by |Q|, that is, and a ∈ τ (q ′′ ).Hence, the computation continues with where either c ∈ τ (q ′′ ), ε = 1, and q ∈ δ(q ′′ , ¡), or c ̸ ∈ τ (q ′′ ), ε = 0, q ∈ δ(q ′′ , c), and q ∈ δ(q, ¡) for some state q ∈ Q.However, in this case, C can also execute the following computation: Observe that the above proof shows, in particular, that the deterministic linear language { a m ca m c | m ≥ 0 } is not accepted by any nrNFAwtl.Together, Proposition 4.17 and Proposition 4.18 yield the following separation result, as by Theorem 4.11, L(NROWJFA) ⊊ L(nrNFAwtl).Proof.Let A = (Q, Σ, ¡, τ, q 0 , F, δ) be the DFAwtl that is defined as follows: Q = {q 0 , q a , q b , q c }, Σ = {a, b, c}, and F = {q c }, τ (q 0 ) = ∅, τ (q a ) = {a}, τ (q b ) = {b}, and τ (q c ) = ∅, δ(q 0 , a) = q a , δ(q 0 , b) = q b , δ(q 0 , c) = q c , δ(q a , b) = q 0 , δ(q b , a) = q 0 .
Starting in its initial state q 0 , A reads the first letter x on its tape.If this letter is an a (b), then A enters the state q a (q b ), in which it looks for the first occurrence of the letter b (a) that is only preceded by occurrences of the letter a (b).If such a letter is found, then it is read (and deleted), and A returns to its initial stateotherwise, it gets stuck.Finally, if an occurrence of the letter c is read in state q 0 , then A halts immediately, and it accepts iff the input has been read completely, which means that there is only a single occurrence of the letter c, which is the last letter of the given input.It follows that, indeed, L(A) = L c .
On the other hand, we have the following negative result.
Proposition 4.22.The language L c is not accepted by any rr-NFA.
Proof.Assume to the contrary that A = (Q, Σ, q 0 , F, ∆, δ) is an rr-NFA such that L(A) = L c .We derive a contradiction by showing that, together with the words of the language L c , the rr-NFA A also accepts some words that are not elements of L c .
For m ≥ 1, let w m = a m b 2m a m c ∈ L c .Then A has an accepting computation for input w m , which begins as follows: where k is an integer satisfying 0 ≤ k ≤ m.During these first m steps, A consumes m − k occurrences of the letter a by applying its transition function δ, and it shifts k occurrences of the letter a to the end of the tape by applying the function ∆.For a large value of m, we now analyze these first m steps in detail by differentiating between several cases.
Case 1: There exists a continuous subsequence of r ≥ |Q| steps such that, in each of them, an occurrence of the letter a is read (and deleted).Then, the above initial part of the accepting computation of A on input w m can be written as follows: where 0 ≤ j 1 ≤ i 1 .As r ≥ |Q|, there exist indices 1 ≤ s < t ≤ r + 1 such that q s = q t , that is, we have Now we take the input word y m+t−s = a m+t−s b 2m a m c.Observe that y m+t−s ̸ ∈ L c , as t − s > 0. However, A can execute the following computation on input y m+t−s : and the latter configuration occurs in the accepting computation of A on input w m .Thus, with the word w m , the rr-NFA A also accepts the word y m+t−s ̸ ∈ L c .
Case 2: There does not exist a continuous subsequence of r ≥ |Q| steps such that, in each of them, an occurrence of the letter a is read (and deleted), but there is a continuous subsequence of r ≥ |Q| steps such that, in each of them, an occurrence of the letter a is rotated to the end of the tape.Then, the initial part of the above accepting computation of A on input w m can be written as follows: where 0 ≤ j 1 ≤ i 1 .As r ≥ |Q|, there exist indices 1 ≤ s < t ≤ r + 1 such that q s = q t , that is, we have Now we take the input z m,t−s = a m−(t−s) b 2m a m ca t−s .Observe that z m,t−s ̸ ∈ L c , as t − s > 0. However, A can execute the following computation on input z m,t−s : and the latter configuration occurs in the accepting computation of A on input w m .Thus, with the word w m , the rr-NFA A also accepts the word z m,t−s ̸ ∈ L c .
Case 3: There is neither a continuous subsequence of r ≥ |Q| steps such that, in each of them, an occurrence of the letter a is read (and deleted) nor a continuous subsequence of r ≥ |Q| steps such that, in each of them, an occurrence of the letter a is rotated to the end of the tape.This means that, if m is sufficiently large, then subsequences of deletions of occurrences of the letter a and subsequences of rotations of occurrences of the letter a alternate more than |Q| times.Thus, there exists a state q ∈ Q such that the above initial part of the accepting computation of A on input w m contains a subcomputation of the following form: , where 1 ≤ s < r.Now we take the input z m,r,s = a m−r b 2m a m ca s .Obviously, z m,r,s ̸ ∈ L c , as s ≥ 1 and r > 1.
However, A can execute the following computation on input z m,r,s : and the latter configuration occurs in the accepting computation of A on input w m .Thus, with the word w m , the rr-NFA A also accepts the word z m,r,s ̸ ∈ L c .
As this covers all possibilities, it follows that L(A) ̸ = L c , completing the proof of Proposition 4.22.
Together, Lemma 4.21 and Proposition 4.22 imply that L(DFAwtl) is not contained in L(rr-NFA).Together with Proposition 4.17 and Proposition 4.18, this yields the following incomparability result.
Observe that the language L c is a rational trace language.In fact,  (c, c)}.Hence, we see that L(rr-NFA) does not contain all rational trace languages.However, as for nrNFAwtl and nrDFAwtl, it seems to be still open whether rr-DFA and rr-NFA only accept languages that are semi-linear.
The diagram in Figure 2 summarizes the inclusion and incomparability results obtained.All arrows in that diagram denote proper inclusions, and classes that are not connected by a sequence of arrows are incomparable under inclusion.The only possible exception is the question of whether L(JFA) is contained in GCSL.

CSL
The inclusion relations between the various types of jumping automata, rightrevolving automata, and automata with translucent letters.

The fixed membership problem for the nrDFAwtl
The fixed membership problem is certainly the most fundamental among the decision problems for automata and languages.Let A be an automaton of a certain fixed type, e.g., a DFA or an nrDFAwtl, with an input alphabet Σ.Then the membership problem for A can be stated as follows: INSTANCE : A word w ∈ Σ * .QUESTION : Is w an element of the language L(A)?
The membership problem for each nrDFAwtl is solvable in linear space, as an nrDFAwtl can easily be simulated by a deterministic linear-bounded automaton.Moreover, it is straightforward to see that L(nrDFAwtl) ⊆ DTIME(n 2 ), since an nrDFAwtl can also be simulated by a two-tape Turing machine in quadratic time, that is, the membership problem for an nrDFAwtl is decidable in quadratic time.In fact, we can do better than that.If A is an nrDFAwtl over a unary alphabet, then, by Proposition 3.3, the language accepted by A is necessarily regular.Hence, we can use a DFA to solve the corresponding membership problem, that is, this problem is decidable in linear time.
In [16], Nagy and Kovács present a construction that shows that the membership problem for a DFAwtl is solvable in time O(n • log n) by a random access machine (a RAM) using the logarithmic complexity measure.For a given input word w, they first construct a specific data structure that is then used to simulate the computation of the given DFAwtl on input w.By using a variation of that technique, we derive the following result.Proof.Let A = (Q, Σ, ¡, τ, q 0 , δ) be an nrDFAwtl such that |Σ| = 2.By Lemma 2.9, we can assume that A never gets into an infinite computation and that it accepts only after reading and deleting its input completely.From the proof of that lemma, we can moreover conclude that, for a word w of length n, the computation of A on input w consists of only O(n) many steps.Furthermore, for all states q ∈ Q and all letters c ∈ Σ ∪ {¡}, if c ̸ ∈ τ (q) and if δ(q, c) is undefined, then we extend the transition function δ by taking δ(q, c) = Reject.
For the following considerations, we assume for simplicity that Σ = {a, b}.Therefore, each input word w ∈ Σ + can be written as where m ≥ 0, i 1 ≥ 0, i 2 , i 3 , . . ., i 2m ≥ 1, and i 2m+1 ≥ 0. For each 1 ≤ j ≤ 2m + 1, if j is odd, then the factor a ij is called an a-block of w, and if j is even, then the factor b ij is called a b-block of w.Now, for all j = 1, 2, . . ., 2m + 1, we realize a record rec j of type block that records the j-th block of w: Here the component symbol gives the type of the block, where £ (¡) is used for the block that symbolizes the beginning (end) of the input, the component length encodes the length of the current block, and prev and next are pointers to the records of type block that correspond to the previous block and the next block.Obviously, a natural number like length is represented in binary, and pointers like prev and next are represented as addresses coded in binary.Thus, such a record of type block can be represented by a diagram as in Figure 3.
The algorithm for solving the membership problem for the nrDFAwtl A proceeds in two major steps: 1. Let w ∈ Σ * be given as input.If w = λ, then the algorithm accepts immediately if λ ∈ L(A); otherwise, it rejects.If w ̸ = λ, then a representation of w • ¡ as a sequence of records of type block is constructed.2. Using the sequence of records of type block constructed in step 1, the computation of the nrDFAwtl A on input w is simulated.The algorithm accepts if this computation accepts; otherwise, it rejects.
This algorithm uses two procedures.The first of them, Build List of Blocks, generates the representation of the word w • ¡, while the second one, Simulate nrDFAwtl, uses that representation to determine whether w is accepted by the nrDFAwtl A.
For example, if w = aabbba, then the procedure Build List of Blocks generates the following doubly-linked list, where we represent the various pointers by double arrows: It is easily seen that, for an input of the form w • ¡, where w ∈ {a, b} n , the procedure Build List of Blocks executes O(n) many steps.
The procedure Simulate nrDFAwtl keeps the current state q, the current block B, and the position r of the head of the nrDFAwtl A within the current block.Whenever A reads and deletes a letter from B, then the length of B is reduced by one.If block B is emptied during that process, then this block is cut out from the sequence, and its predecessor C and its successor D are merged.In this situation, the head of the nrDFAwtl A is placed on the r-th letter of this new block, where r = C.length + 1.If the last letter of B was read and deleted (but B was not emptied), the head of A moves to the first letter of the next block.The while-loop ends as soon as a transition of A is simulated that yields Accept or Reject.It is again easily seen that, for an input of the form w • ¡, where w ∈ {a, b} n , the procedure Simulate nrDFAwtl executes O(n) many steps.
Finally, we combine these two procedures into an algorithm for solving the membership problem for the nrDFAwtl A (see Algorithm Solve Membership Problem for nrDFAwtl A on Binary Alphabet below).Thus, the membership problem for the nrDFAwtl A is solved in O(n) steps.As the pointers can be realized by integers of size up to n only, we see that each step just manipulates a finite number of characters or integers of size up to n.As the integers are represented in binary form, each step takes time O(log n) only.It follows taken, as in this case, the next letter encountered by A is the right sentinel ¡.Next, the transition δ(p, w[s]) of A is simulated, where w[n + 1] refers to the sentinel ¡, and if s < n + 1, that is, a letter a ∈ Σ occurs at position s, then this position is deleted from the tree T a .This process continues until an accepting or rejecting transition of A is reached.Note that the input w • ¡ is not modified during the simulation of the computation of the nrDFAwtl A.
It can be easily seen that this algorithm processes the input w • ¡ in O(n • log n) steps.As each step just manipulates a finite number of characters or integers of size up to n + 1, it follows that this algorithm can be realized in time O(n • (log n) 2 ) by a RAM using the logarithmic cost measure.
It remains open whether the upper bound of O(n • (log n) 2 ) for the time complexity of the problem for an nrDFAwtl on an alphabet of cardinality larger than two can be improved.For the nondeterministic case, we obtain that the membership problem for an nrNFAwtl can be solved nondeterministically in time O(n • log n) in the case of a binary alphabet and in time O(n • (log n) 2 ) in the case of an alphabet of cardinality larger than two.However, we currently do not have any subexponential upper bound for the deterministic time complexity of the fixed membership problem for the nrNFAwtl.
We close this section by taking a look at the emptiness problem and the finiteness problem for non-returning finite automata with translucent letters.These problems can be stated as follows: The emptiness problem for nrNFAwtls: INSTANCE : An nrNFAwtl A. QUESTION : Is the language L(A) empty?
The finiteness problem for nrNFAwtls: INSTANCE : An nrNFAwtl A. QUESTION : Is the language L(A) finite?For NFAwtls, these problems are decidable in polynomial time.In fact, from an NFAwtl A, one can construct an NFA B such that L(B) is a subset of L(A) that is letter-equivalent to L(A), which means that L(B) is a regular sublanguage of L(A) that has the same Parikh image as L(A).Therefore, the language L(A) is empty (or finite) if and only if the language L(B) is empty (or finite).In particular, this shows that the language L(A) is empty if and only if the transition graph of the NFA B does not contain a path from an initial state to a final state.However, the situation is more complicated for non-returning NFAs with translucent letters.
From the diagram describing a given nrNFAwtl A, we can immediately extract information on the patterns of the words that A can scan during a single sweep (or cycle).Of course, if there is a sweep that starts in an initial state and that reaches a state in which A accepts at the end-of-tape marker, then the corresponding words are accepted by A, which means that they are witnesses for the fact that the language L(A) is non-empty.In general, however, A may not have any accepting computations that just consist of single sweeps.For example, this is the case for the nrDFAwtl A ex3 considered in Example 3.4.In this situation, each accepting computation consists of a sequence of sweeps such that the words that A scans during these sweeps form a sequence that can be combined into an accepted word.However, it is not clear whether this can always be done.To illustrate this problem, we consider a simple example.
This nrDFAwtl is depicted by the diagram in Figure 4. From this diagram, we can immediately extract three types of cycles: (1) However, these three cycles cannot be combined into an accepting computation of A. The third cycle (or sweep) requires that there is an occurrence of the letter c, which may only be preceded by occurrences of the letter a.
The second cycle requires that there is an occurrence of the letter b, which may only be preceded by occurrences of the letter c.Finally, the first cycle requires that there is an occurrence of the letter a that may only be preceded by occurrences of the letter b and that may only be followed by occurrences of the letter c.Together, these requirements imply that there is no word that A accepts, that is, L(A) = ∅.
Thus, it remains to determine whether, from a given finite set of patterns of words that are accepted by an nrNFAwtl A in different sweeps (or cycles), one can extract sufficient information for deciding whether there exists a word that is accepted by A, that is, whether, from the various patterns, a word can be obtained that is compatible with all these patterns.Accordingly, it remains open whether the emptiness problem or the finiteness problem are decidable for non-returning NFAs (DFAs) with translucent letters.

Conclusion
We have extended the NFAwtl and its deterministic variant, the DFAwtl, to the non-returning NFAwtl and the non-returning DFAwtl by abandoning the requirement that, in each step, the automaton reads and deletes the first letter from the beginning of the current word on its tape that is not translucent for the current state.As it turned out, the non-returning types of automata are indeed more expressive than the original types.We then compared the non-returning NFAwtl and the non-returning DFAwtl to some other types of automata that do not read their inputs strictly from left to right.Here, the deterministic and nondeterministic right one-way jumping finite automata ((N)ROWJFA) are of particular interest, as the nrNFAwtl (nrDFAwtl) differs from the NROWJFA (ROWJFA) only in that the former can detect the end of the input, which is marked by the sentinel ¡, while the latter has no way of doing so.We have seen that this ability yields a proper increase in expressive capacity.In fact, we obtained a complete hierarchy of language classes that are accepted by the various types of finite automata considered.Also, we derived some closure and non-closure properties for the classes of languages that are accepted by nrNFAwtls and nrDFAwtls.Finally, we established that the membership problem for a non-returning DFAwtl is decidable in time O(n • log n) for the case of a binary alphabet and that it is decidable in time O(n • (log n) 2 ) in the general case.However, many questions concerning the nrNFAwtl and the nrDFAwtl are still open:

Theorem 3 . 7 .
The language class L(nrDFAwtl) is closed under complementation and disjoint shuffle, but it is neither closed under union nor under intersection.Moreover, this class is not closed under alphabetic morphisms.Proof.The language L 1 = { w ∈ {a, b} * | |w| a = |w| b } and the language L 2 = { w ∈ {a, b} * | |w| b = 2 • |w| a } are accepted by DFAwtls.However, L 1 ∪ L 2 = L ∨ , which is not even accepted by any nrDFAwtl by Proposition 3.5.This shows that the class L(nrDFAwtl) is not closed under union.

Corollary 4 . 16 .
The language classes L(ROWJFA), L(NROWJFA), L(rr-DFA), and L(rr-NFA) are incomparable to the class GCSL with respect to inclusion.It remains open whether the class L(JFA) is contained in GCSL.

Corollary 4 . 19 .
The language class L(NROWJFA) is a proper subclass of the language class L(rr-NFA).In addition, these propositions also show that L(rr-DFA) and L(rr-NFA) are not contained in L(nrDFAwtl) or L(nrNFAwtl).Moreover, in analogy to Example 2.7, the language { a m cb m c | m ≥ 0 } can be shown to be accepted by an nrDFAwtl.If φ : {a, b, c} * → {a, c} * is the morphism defined through a → a, b → a, and c → c, then φ({ a m cb m c | m ≥ 0 }) = { a m ca m c | m ≥ 0 }.Hence, we obtain the following non-closure result.Corollary 4.20.The language class L(nrNFAwtl) is not closed under alphabetic morphisms.Finally, we consider the language L c = { wc | w ∈ {a, b} * , |w| a = |w| b }.Lemma 4.21.L c ∈ L(DFAwtl).

Theorem 5 . 1 .
The membership problem for an nrDFAwtl over a binary alphabet is decidable in time O(n • log n).

Figure 3 .
Figure 3.The graphical representation of a record of type block.