Finite Automata with Translucent Letters

Updated 5 July 2026

Finite automata with translucent letters are finite-state devices that use state-dependent translucency to skip and delete symbols, enabling discontinuous input processing.
They extend classical models by handling non-regular and non-context-free languages through controlled restarting, non-returning continues, and repetitive sweeps.
Variants such as returning, non-returning, and repetitive modes impact expressive power, closure properties, and computational complexity, offering diverse theoretical insights.

Searching arXiv for papers on finite automata with translucent letters and closely related variants. arxiv.search(query="finite automata translucent letters", max_results=10, sort_by="submittedDate") Finite automata with translucent letters are finite-state devices for discontinuous input processing in which the current state determines a set of letters that are translucent, hence invisible, at that moment. The machine skips the leftmost block of currently translucent letters, acts on the first visible letter, deletes that occurrence, and continues according to its operational mode. Introduced by Nagy and Otto and connected in origin to cooperative distributed systems of stateless restarting automata with window size one, these automata define language families that properly extend ordinary finite automata, include non-regular and even some non-context-free languages, and exhibit an unusually rich interaction among determinism, repeated sweeps, and state-dependent visibility (Nagy, 2023, Mráz et al., 2024).

1. Formal model and core mechanism

The standard returning model is the nondeterministic finite automaton with translucent letters ( $\mathrm{NFAwtl}$ ), together with its deterministic restriction $\mathrm{DFAwtl}$ . In the formulation used in recent work, an $\mathrm{NFAwtl}$ is a tuple

$A=(Q,\Sigma,\lhd,\tau,I,F,\delta),$

where $Q$ is a finite state set, $\Sigma$ is the input alphabet, $\lhd\notin\Sigma$ is an end-of-tape marker, $\tau:Q\to\mathcal P(\Sigma)$ is the translucency mapping, $I\subseteq Q$ is the set of initial states, $F\subseteq Q$ is the set of final states, and $\mathrm{DFAwtl}$ 0 is the transition relation, subject to

$\mathrm{DFAwtl}$ 1

Thus translucency and readability are disjoint in the original model (Mráz et al., 2024).

The operational semantics is deletion-based. A configuration has the form $\mathrm{DFAwtl}$ 2, with scanning conceptually restarted at the left end of the current residual word. If

$\mathrm{DFAwtl}$ 3

then $\mathrm{DFAwtl}$ 4 is the leftmost visible letter in state $\mathrm{DFAwtl}$ 5. If $\mathrm{DFAwtl}$ 6, the automaton performs

$\mathrm{DFAwtl}$ 7

Only the visible occurrence $\mathrm{DFAwtl}$ 8 is deleted; the skipped translucent prefix $\mathrm{DFAwtl}$ 9 remains. If the remaining word lies in $\mathrm{NFAwtl}$ 0, then the end marker is effectively reached, and the computation accepts iff $\mathrm{NFAwtl}$ 1; otherwise it rejects (Mráz et al., 2024).

A closely related normal-form presentation dispenses with an explicit end marker and encodes translucency through undefined transitions. In that form, a jump step is written

$\mathrm{NFAwtl}$ 2

iff $\mathrm{NFAwtl}$ 3 and no letter occurring in the skipped prefix $\mathrm{NFAwtl}$ 4 has a defined transition from $\mathrm{NFAwtl}$ 5. This formulation makes explicit that a letter is translucent in a state exactly when the automaton has no transition on it there (Mitrana et al., 2023).

The essential computational idea is therefore not one-way reading, but state-dependent visibility plus deletion of the first visible symbol. A symbol may be invisible in one state and later visible in another, so the same residual word can be exposed in different ways during a computation (Nagy, 2023).

2. Returning, non-returning, and repetitive operation

The classical $\mathrm{NFAwtl}$ 6 are returning: after every deletion, scanning restarts from the left end of the residual input. Later work isolated two further operational dimensions: non-returning computation, where the head continues from the deletion point, and repetitive computation, where reaching the right end need not force immediate halting (Mráz et al., 2022, Mráz et al., 2024).

Variant	Defining operational feature	Established relation
$\mathrm{NFAwtl}$ 7	return to the left end after each deletion	base returning model
$\mathrm{NFAwtl}$ 8	on $\mathrm{NFAwtl}$ 9, may change state and continue on the same residual word	deterministic case strictly stronger than $A=(Q,\Sigma,\lhd,\tau,I,F,\delta),$ 0; nondeterministic case equivalent to $A=(Q,\Sigma,\lhd,\tau,I,F,\delta),$ 1
$A=(Q,\Sigma,\lhd,\tau,I,F,\delta),$ 2	after deletion, continue from the deletion point; on $A=(Q,\Sigma,\lhd,\tau,I,F,\delta),$ 3, may accept, reject, or restart	strictly stronger than returning models
$A=(Q,\Sigma,\lhd,\tau,I,F,\delta),$ 4	non-returning but non-repetitive	exactly the regular languages

In the non-returning model, configurations record an internal head position, typically as $A=(Q,\Sigma,\lhd,\tau,I,F,\delta),$ 5, where $A=(Q,\Sigma,\lhd,\tau,I,F,\delta),$ 6 is the already-passed prefix and $A=(Q,\Sigma,\lhd,\tau,I,F,\delta),$ 7 is the unread suffix. If $A=(Q,\Sigma,\lhd,\tau,I,F,\delta),$ 8 with $A=(Q,\Sigma,\lhd,\tau,I,F,\delta),$ 9 and $Q$ 0, then deletion yields $Q$ 1; the head remains at the deletion point rather than returning left. Only when the remaining suffix consists entirely of translucent letters does the machine consult its $Q$ 2-action, which may accept, reject, or restart from the left of the remaining tape (Mráz et al., 2022, Kutrib et al., 25 Jun 2026).

The repetitive returning model occupies an intermediate position. An $Q$ 3 replaces the final-state test at the end marker by a transition map

$Q$ 4

Hence, when $Q$ 5, the automaton may halt or may move to a new state $Q$ 6 and continue on the same residual word $Q$ 7, again starting from the left. This change is enough to enlarge deterministic power, but not nondeterministic power (Mráz et al., 2024).

A striking boundary result is that the purely non-returning but non-repetitive model collapses to regular languages. Thus the major increase in power does not come from non-returningness alone; it comes from combining selective visibility with controlled restarting regimes (Mráz et al., 2024).

3. Expressive power and separations

Finite automata with translucent letters have a much larger expressive range than ordinary DFA and NFA. The nondeterministic model accepts all commutative semi-linear languages and all rational trace languages, including various languages that are not context-free. The deterministic model is weaker, but it still contains all regular languages, some non-regular context-free languages such as the one-type Dyck language, and also some languages that are not even context-free (Nagy, 2023).

This already places the model outside the standard regular/context-free hierarchy. One deterministic example accepts a language whose intersection with the regular set $Q$ 8 is

$Q$ 9

showing that deterministic translucent-letter automata can enforce a non-context-free counting pattern. Another classical deterministic example accepts the one-type Dyck language using only two states by alternating between a state that must delete an opening symbol and a state in which openings are translucent and the first visible closing symbol is deleted (Nagy, 2023).

Determinism and nondeterminism separate in the finite-state setting. A standard witness is

$\Sigma$ 0

which is accepted by an $\Sigma$ 1 but not by any deterministic returning repetitive model, hence not by $\Sigma$ 2 either. The deterministic repetitive model nevertheless strictly exceeds $\Sigma$ 3: the language

$\Sigma$ 4

is accepted by an $\Sigma$ 5 but not by any $\Sigma$ 6. By contrast,

$\Sigma$ 7

so repetitiveness adds no expressive power in the nondeterministic returning case (Mráz et al., 2024).

The non-returning variants are strictly stronger than the returning ones. A canonical witness is

$\Sigma$ 8

which is accepted by an $\Sigma$ 9 but by no $\lhd\notin\Sigma$ 0. In the standard construction, one sweep deletes one $\lhd\notin\Sigma$ 1, one $\lhd\notin\Sigma$ 2, and one $\lhd\notin\Sigma$ 3, then a restart at $\lhd\notin\Sigma$ 4 begins the next cycle. This proves

$\lhd\notin\Sigma$ 5

(Mráz et al., 2022).

At the same time, the non-returning deterministic family remains restricted. It does not contain all rational trace languages; in particular $\lhd\notin\Sigma$ 6. Likewise, the nondeterministic non-returning family does not contain all deterministic linear languages: the language $\lhd\notin\Sigma$ 7 generated by

$\lhd\notin\Sigma$ 8

is not in $\lhd\notin\Sigma$ 9 (Mráz et al., 2022).

A distinct line of work studies how much translucency is used in an accepting computation. In the normal-form presentation, the jumping complexity of a word is the minimum number of genuine jump steps among all accepting computations, and the machine-level function $\tau:Q\to\mathcal P(\Sigma)$ 0 or $\tau:Q\to\mathcal P(\Sigma)$ 1 measures the worst case over accepted words of length $\tau:Q\to\mathcal P(\Sigma)$ 2. For every automaton this quantity is at most linear, since each step deletes one symbol (Mitrana et al., 2023, Fazekas et al., 23 Jun 2025).

The first general result in this direction was that bounded jump use does not exceed regular power. For any finite automaton with translucent letters $\tau:Q\to\mathcal P(\Sigma)$ 3 and any constant $\tau:Q\to\mathcal P(\Sigma)$ 4, the language

$\tau:Q\to\mathcal P(\Sigma)$ 5

is regular, and therefore

$\tau:Q\to\mathcal P(\Sigma)$ 6

However, the converse fails at the level of machine descriptions: a particular translucent-letter automaton may accept a regular language while requiring unboundedly many jumps on some accepted inputs (Mitrana et al., 2023).

For deterministic translucent-letter automata, the asymptotic behavior is much more rigid. The 2025 analysis proves that the jump complexity of a $\tau:Q\to\mathcal P(\Sigma)$ 7 is either bounded by a constant or linear; there is no genuinely intermediate asymptotic regime. It also gives a polynomial-time algorithm, with complexity

$\tau:Q\to\mathcal P(\Sigma)$ 8

to decide whether a given $\tau:Q\to\mathcal P(\Sigma)$ 9 has constant-bounded or linear jump complexity. In the constant-jump case, equivalence is decidable, and for binary alphabets the regularity problem for $I\subseteq Q$ 0 is decidable in $I\subseteq Q$ 1 time. This stands in contrast to $I\subseteq Q$ 2, for which regularity is known to be undecidable (Fazekas et al., 23 Jun 2025).

Two additional refinements reshape the theory in different directions. The first is the state-deterministic model ( $I\subseteq Q$ 3), in which the next state depends only on the current state and not on which visible letter was processed. This model remains strong enough to accept the Dyck language and some non-context-free languages, but it does not contain all regular languages; $I\subseteq Q$ 4 is an explicit counterexample. The second is the model with nondeterministically translucent letters, denoted $I\subseteq Q$ 5, where a letter may be both translucent and readable in the same state. This properly generalizes the original model, but all accepted languages remain semilinear because every $I\subseteq Q$ 6-language has a letter-equivalent regular sublanguage (Nagy, 2023).

5. Closure properties and decision problems

The language-theoretic behavior of translucent-letter automata is notably uneven. For the returning nondeterministic model, known closure properties include union, concatenation, Kleene star, inverse projections, disjoint shuffle, and commutative closure, whereas non-closure is known for intersection with regular languages, complementation, and non-erasing morphisms. A later result settled another longstanding question negatively: neither $I\subseteq Q$ 7 nor $I\subseteq Q$ 8 is closed under inverse non-erasing homomorphism. The proof uses the fact that every language in $I\subseteq Q$ 9 contains a letter-equivalent regular sublanguage, a property incompatible with the equal-length language $F\subseteq Q$ 0 arising as an inverse image in the construction (Mráz et al., 2024, Kutrib et al., 25 Jun 2026).

For the non-returning families, earlier work established that $F\subseteq Q$ 1 is closed under union and disjoint shuffle, while $F\subseteq Q$ 2 is closed under complementation and disjoint shuffle but is not closed under union, intersection, or alphabetic morphisms. Later work resolved a cluster of open problems: both $F\subseteq Q$ 3 and $F\subseteq Q$ 4 are not closed under concatenation, Kleene star, reversal, and inverse non-erasing homomorphism. In addition, $F\subseteq Q$ 5 is not closed under complementation (Mráz et al., 2022, Kutrib et al., 25 Jun 2026).

The repetitive returning deterministic family $F\subseteq Q$ 6 has its own closure profile. It is closed under complementation, left quotient by a single word, and disjoint shuffle, but not under union, intersection with regular languages, alphabetic morphisms, commutative closure, reversal, product, Kleene plus, Kleene star, or shuffle. Its nondeterministic counterpart inherits the closure properties of $F\subseteq Q$ 7 because the two classes are equal (Mráz et al., 2024).

Decision problems are similarly split. Membership is efficiently decidable for deterministic models: for $F\subseteq Q$ 8, known algorithms give $F\subseteq Q$ 9 time, and for $\mathrm{DFAwtl}$ 00 membership is decidable in

$\mathrm{DFAwtl}$ 01

time, with the nondeterministic non-returning membership problem in $\mathrm{DFAwtl}$ 02. For $\mathrm{DFAwtl}$ 03, emptiness, finiteness, and universality are decidable, and inclusion is undecidable; equivalence remains open in that setting. For non-returning automata, emptiness was long open, but is now decidable for both $\mathrm{DFAwtl}$ 04 and $\mathrm{DFAwtl}$ 05 via a bounded-sweep reduction to nondeterministic iterated uniform finite-state transducers (Mráz et al., 2024, Mráz et al., 2022, Kutrib et al., 25 Jun 2026).

6. Generalizations and broader significance

Two major extensions show that the translucent-letter mechanism is not an isolated curiosity. The first is the move from translucent letters to translucent words. In a finite automaton with translucent words ( $\mathrm{DFAwtl}$ 06), the invisible prefix must lie in $\mathrm{DFAwtl}$ 07 for a finite prefix code $\mathrm{DFAwtl}$ 08, rather than being formed letterwise. The letter model is recovered exactly as the length- $\mathrm{DFAwtl}$ 09 restriction: “the $\mathrm{DFAwtl}$ 10-length-restricted NFAwtw is just the NFAwtl.” In the ordinary word-based model, every accepted language is semilinear because each language has a letter-equivalent regular sublanguage; but the repetitive word-based deterministic model already accepts the non-semilinear language

$\mathrm{DFAwtl}$ 11

and emptiness for repetitive deterministic translucent-word automata is undecidable (Mráz et al., 21 Jul 2025).

The second extension adds stack memory. The 2025 work on input-driven pushdown automata with translucent input letters preserves exactly the same visibility mechanism—state-dependent invisibility, repeated sweeps, and returning versus non-returning operation—while superimposing a visibly pushdown discipline. In that setting, deterministic and nondeterministic models separate, and non-returning computation is strictly stronger than returning computation. The paper explicitly presents this as a direct extension of the finite-automaton concept rather than a different idea (Kutrib et al., 21 Jul 2025).

These extensions clarify the theoretical role of translucency. A plausible implication is that the main computational resource is not merely deletion or restarting, but the ability to make symbols invisible now and visible later depending on state. In the finite-state case this yields a family with nontrivial expressiveness, delicate closure properties, and sharp deterministic–nondeterministic contrasts; in the word-based and pushdown-based cases the same mechanism can drive non-semilinearity, stronger separations, and harder undecidability phenomena (Mráz et al., 21 Jul 2025, Kutrib et al., 21 Jul 2025).