Complete Reversible 2-Head Finite Automata

• Complete reversible 2-head finite automata are deterministic devices that process input from both ends while ensuring unique reversible computations and complete input traversal.
• They impose strict conditions on determinism, completeness, and reversibility, which defines a hierarchy and limits their power compared to general reversible 2-head models.
• The automata exhibit closure under reversal and complementation, effectively characterizing languages such as palindromes and specific linear sets.

Searching arXiv for the specified paper and related metadata. Complete reversible 2-head finite automata are deterministic 2-head finite automata that process an input word from both ends and perform reversible computation, so that both forward and backward computation are unique. In the formulation studied by Nagy and Yasin, completeness requires that any input can be fully read by the automaton, and reversibility requires backward determinism; the resulting family of accepted languages, denoted $2CrevLIN$, is strictly weaker than the classes accepted by 1-limited reversible, reversible, and deterministic 2-head automata. The broader reversible 2-head model can accept some characteristic linear languages, such as the language of palindromes, but it does not cover all regular languages (Nagy et al., 21 Jul 2025).

1. Formal definition and acceptance semantics

Let $\Sigma$ be a finite input alphabet and let $\,\⊢,\⊣$ be left and end markers not in $\Sigma$. A complete reversible two-head finite automaton is a tuple

$A=(Q,\Sigma,q_0,F,\delta),$

where $Q$ is a finite set of states, $q_0\in Q$ is the initial state, $F\subseteq Q$ is the set of accepting states, and

$\delta:Q\times(\Sigma\cup\{\⊢,\⊣\})^2\longrightarrow Q\times\{L,R\}^2.$

If the automaton is in state $q$ and the two heads scan $\Sigma$0, then

$\Sigma$1

means that the control changes to $\Sigma$2, head $\Sigma$3 moves one step in direction $\Sigma$4, and head $\Sigma$5 moves one step in direction $\Sigma$6.

Three conditions are imposed. Determinism requires that for every $\Sigma$7 and every pair $\Sigma$8, the transition is unique. Completeness requires that, as long as at least one unread input symbol remains under one of the heads, exactly one transition is specified. Equivalently, for every

$\Sigma$9

there is exactly one $\,\⊢,\⊣$0. Reversibility requires injectivity of the global transition relation on configurations. The local form of this condition is that if

$\,\⊢,\⊣$1

and

$\,\⊢,\⊣$2

then necessarily

$\,\⊢,\⊣$3

This local injectivity ensures that every node in the global configuration graph has at most one predecessor (Nagy et al., 21 Jul 2025).

Acceptance is defined by head meeting. The accepted language is

$\,\⊢,\⊣$4

The emphasis on meeting configurations distinguishes the model from one-way reversible automata and ties acceptance directly to complete traversal of the marked input.

2. Completeness, 1-limitedness, and state classification

Completeness forces the machine to continue until the input has been fully read. Intuitively, one head or the other must keep moving until no unread symbol remains. The 1-limited reversible variant imposes a stronger local condition: in each computation step exactly one input letter is being processed, that is, only one of the heads can read a letter. In equivalent operational terms, in every transition exactly one head moves and the other stays put (Nagy et al., 21 Jul 2025).

For complete reversible machines, the paper states that any transition in which both heads move simultaneously would violate completeness together with reversibility. A direct consequence is that every complete reversible 2-head automaton is automatically 1-limited. This is a structural restriction rather than a matter of implementation style, and it is one reason that completeness lowers expressive power relative to general reversible 2-head automata.

The 1-limited reversible model is also described through a classification of states based on two pieces of information: which head was used to enter the state, and which head is allowed to move out of the state. This produces up to seven non-empty classes. For a complete reversible automaton, the same seven classes suffice, because every state must allow some move by completeness and must be re-enterable from exactly one head-move by reversibility. This state-based view makes explicit how reversibility constrains the local flow of control.

3. Expressive power and proper hierarchy

The paper introduces four language families associated with two-head machines:

Notation	Meaning
$\,\⊢,\⊣$5	languages of deterministic 2-head automata
$\,\⊢,\⊣$6	languages of reversible, but not necessarily complete, 2-head automata
$\,\⊢,\⊣$7	languages of 1-limited reversible 2-head automata
$\,\⊢,\⊣$8	languages of complete reversible 2-head automata

These families satisfy the strict inclusion chain

$\,\⊢,\⊣$9

The hierarchy shows that reversibility already reduces the power of deterministic 2-head automata, and that 1-limitedness and completeness each impose further proper restrictions (Nagy et al., 21 Jul 2025).

Several witness languages establish the properness of the inclusions. Some simple regular languages already fall outside $\Sigma$0: the language

$\Sigma$1

cannot be accepted by any reversible 2-head automaton. This rules out the assumption that reversibility is merely a semantic refinement that leaves regular-language recognition intact.

The separation between $\Sigma$2 and $\Sigma$3 is witnessed by the language

$\Sigma$4

which is accepted by a reversible 2-head automaton, but by no 1-limited reversible device. The separation between $\Sigma$5 and $\Sigma$6 is witnessed by

$\Sigma$7

which is accepted by a 1-limited reversible 2-head automaton, but by no complete reversible 2-head automaton. In the broader setting, reversible 2-head automata are also capable of accepting some characteristic linear languages, for example the language of palindromes.

4. Closure properties and comparison with left-deterministic linear grammars

All four classes,

$\Sigma$8

are closed under reversal. Operationally, reversal is obtained by swapping the two heads in every transition. This closure is natural for a model whose computation is defined symmetrically with respect to the two ends of the input (Nagy et al., 21 Jul 2025).

Complete reversible machines are additionally closed under complementation. If

$\Sigma$9

is complete and reversible, then

$A=(Q,\Sigma,q_0,F,\delta),$0

accepts exactly

$A=(Q,\Sigma,q_0,F,\delta),$1

This complement construction depends on completeness: any input can be fully read, so toggling the final-state set yields the complementary language without introducing undefined behavior.

The paper also compares these automaton families with classes generated by left deterministic linear grammars. Left-deterministic linear languages form a proper subclass of $A=(Q,\Sigma,q_0,F,\delta),$2. At the same time, LDLL and $A=(Q,\Sigma,q_0,F,\delta),$3 are incomparable: some left-deterministic linear languages are not reversible-2-head, and some reversible-2-head languages are not left-deterministic. This comparison places complete reversible 2-head automata within a broader landscape of linear-language formalisms rather than treating them as an isolated automaton variant.

5. Illustrative complete reversible automaton

An explicit toy example is given over $A=(Q,\Sigma,q_0,F,\delta),$4. The automaton accepts all words in $A=(Q,\Sigma,q_0,F,\delta),$5. Its idea is to scan the entire input left-to-right with head $A=(Q,\Sigma,q_0,F,\delta),$6 only, then scan it right-to-left with head $A=(Q,\Sigma,q_0,F,\delta),$7 only, and finally halt in an accepting state when the two heads meet. The state set is

$A=(Q,\Sigma,q_0,F,\delta),$8

with $A=(Q,\Sigma,q_0,F,\delta),$9 initial and $Q$0. Both states are reachable, and only $Q$1 is accepting (Nagy et al., 21 Jul 2025).

The transition description is divided into phases. In state $Q$2, phase $Q$3 moves head $Q$4 to the right until it scans $Q$5: $Q$6 for every $Q$7 and every $Q$8. Once head $Q$9 sees the right endmarker $q_0\in Q$0, the machine switches to phase $q_0\in Q$1 by moving head $q_0\in Q$2: $q_0\in Q$3 Then head $q_0\in Q$4 moves left until it sees $q_0\in Q$5: $q_0\in Q$6 for every $q_0\in Q$7 and $q_0\in Q$8. When head $q_0\in Q$9 reaches the left endmarker, the automaton enters the accepting state: $F\subseteq Q$0

The exposition states three properties of this automaton. It is complete, because at every configuration except the final “both heads at $F\subseteq Q$1” configuration exactly one transition is defined. It is reversible, because locally the mapping

$F\subseteq Q$2

is one-to-one. It accepts $F\subseteq Q$3, because regardless of input length, head $F\subseteq Q$4 first moves all the way right, then head $F\subseteq Q$5 moves all the way left, and the machine accepts.

A sample run on input “ab” is given explicitly:

• start at $F\subseteq Q$6;
• $F\subseteq Q$7, so head $F\subseteq Q$8 moves to $F\subseteq Q$9;
• $\delta:Q\times(\Sigma\cup\{\⊢,\⊣\})^2\longrightarrow Q\times\{L,R\}^2.$0, so head $\delta:Q\times(\Sigma\cup\{\⊢,\⊣\})^2\longrightarrow Q\times\{L,R\}^2.$1 moves to $\delta:Q\times(\Sigma\cup\{\⊢,\⊣\})^2\longrightarrow Q\times\{L,R\}^2.$2;
• $\delta:Q\times(\Sigma\cup\{\⊢,\⊣\})^2\longrightarrow Q\times\{L,R\}^2.$3, so head $\delta:Q\times(\Sigma\cup\{\⊢,\⊣\})^2\longrightarrow Q\times\{L,R\}^2.$4 moves to $\delta:Q\times(\Sigma\cup\{\⊢,\⊣\})^2\longrightarrow Q\times\{L,R\}^2.$5;
• $\delta:Q\times(\Sigma\cup\{\⊢,\⊣\})^2\longrightarrow Q\times\{L,R\}^2.$6, so head $\delta:Q\times(\Sigma\cup\{\⊢,\⊣\})^2\longrightarrow Q\times\{L,R\}^2.$7 moves to $\delta:Q\times(\Sigma\cup\{\⊢,\⊣\})^2\longrightarrow Q\times\{L,R\}^2.$8;
• $\delta:Q\times(\Sigma\cup\{\⊢,\⊣\})^2\longrightarrow Q\times\{L,R\}^2.$9, so head $q$0 moves to $q$1;
• $q$2, so head $q$3 moves to $q$4;
• $q$5, and the input is accepted.

The example is intentionally small, but it exhibits the defining features of the model: deterministic progress, full reading of the input, one-step invertibility, and acceptance at a head-meeting configuration.