Minimal Consistent Layered Automaton

• Minimal Consistent Layered Automaton is a canonical, history-deterministic model that recognizes ω-regular languages via a hierarchy of deterministic transition systems.
• It extends the expressivity of deterministic parity and alternating automata, enabling efficient polynomial-time minimization, consistency checking, and language inclusion testing.
• The automaton employs congruence-based construction and algebraic techniques to guarantee uniqueness, safe-minimality, and effective symbolic manipulation of complex language representations.

A minimal consistent layered automaton provides a canonical, history-deterministic, and uniquely minimal model for recognizing $\omega$-regular languages via a hierarchy of deterministic transition systems, extending the expressivity of deterministic parity automata (DPA) and alternating automata. This model is central to the theory of automata over infinite words, admitting polynomial-time minimization, consistency checking, inclusion testing, and a congruence-based algebraic construction (Casares et al., 22 Jan 2026).

1. Structure and Semantics of Layered Automata

A $d$-layered automaton is defined by the tuple

$$A = \bigl(T_1,\,T_2,\,\dots,\,T_d;\; \mu_1, \mu_2, \dots, \mu_{d-1}; q_{\sf init}\bigr)$$

where:

• $T_x = (Q_x, \delta_x)$ is a deterministic labelled transition system over a finite alphabet $\Sigma$ for each layer $1 \le x \le d$, with transition functions $\delta_x: Q_x \times \Sigma \to Q_x \cup \{\bot\}$. $T_1$ is complete and has a distinguished initial state $q_{\sf init} \in Q_1$.
• All $Q_x$ are pairwise disjoint.
• Each $\mu_x: Q_{x+1} \to Q_x$ is a layer map, forming a depth-$d$ forest rooted at $Q_1$.

The automaton's operational semantics is encoded via an associated alternating parity automaton $[A]$ whose states are the leaves of the forest. Upon reading $a \in \Sigma$ from a leaf $q \in Q_x$, the system "fires" the highest valid layer and selects all $q' \in Q_x$ with $$\widetilde\mu_x(q') = \delta_x(\widetilde\mu_x(q), a)$$, assigning parity $x$. The accept/reject outcome is determined by a parity game, allocating choices to Eve (odd $x$) or Adam (even $x$) (Casares et al., 22 Jan 2026).

2. Consistency, History Determinism, and the 0–1 Law

A layered automaton is consistent if there does not exist a pair of leaves $p, p'$ with identical $\widetilde\mu_1$ ancestors and a word $w \in \Sigma^\omega$ that is strongly accepted from $p$ and strongly rejected from $p'$. Consistency is equivalent to:

• Uniform Semantic Determinism: $([A], p)$ and $([A], p')$ recognize the same language for $p, p'$ sharing $\widetilde\mu_1$.
• History Determinism (HD): $[A]$ admits uniformly history-deterministic strategies for both players.
• 0–1 Law: Under any random walk, the probability of seeing a priority infinitely often is in $\{0, 1\}$, aligning with language membership.

These properties are verified via combinatorial arguments using longest-suffix resolver strategies and random-suffix analysis (Casares et al., 22 Jan 2026).

3. Uniqueness and Canonicality

Every $\omega$-regular language admits a unique, up-to-isomorphism, minimal consistent layered automaton satisfying four structural properties:

• (N1) No transitions crossing SCCs in any $T_x$.
• (N2) For each $q \in Q_x$ and each child $p$ in $\mu_x^{-1}(q)$, there exists $u \in \Sigma^+$ such that $q \xto{u}_x q$ but $p \xto{u}_{x+1} \bot$.
• (Centrality) SCCs are preordered by $x$-safe language inclusion with no incomparable minimal elements.
• (Safe-Minimality) $x$-layer states sharing safe languages up to $x$ are identical.

A canonical isomorphism between any two minimal, normal/central/safe-minimal automata is constructed layer by layer, relying on DFA residuals and enforced uniqueness via safe-minimality (Casares et al., 22 Jan 2026).

4. Polynomial-Time Minimization and Algorithms

Given a consistent layered automaton, a canonical minimal form is computed via three polynomial-time steps:

• Normalisation: Remove transitions crossing SCCs and splice SCCs covered by those in the next layer (enforces (N1), (N2)).
• Safe-Minimisation: States are quotient-ed by the equivalence $p \sim_x q$ if they are equivalent in the previous layer and have identical $x$-safe languages (computed via deterministic safety automata equivalence in PTIME).
• Centralisation: Preorders SCCs based on $x$-safe languages; deletes states violating centrality, shrinking layers iteratively.

All steps are PTIME in $|Q|$, $|\Sigma|$, $d$. The procedure terminates with the unique minimal consistent layered automaton (Casares et al., 22 Jan 2026).

5. Decision Procedures: Consistency, Emptiness, Inclusion

Decision problems for minimal consistent layered automata are efficiently solvable:

• Consistency: For each pair $p, p'$ with same $\widetilde\mu_1$, solve a generalized Büchi game (PTIME per pair, $O(|Q|^2)$ total).
• Emptiness: Existence of a strongly accepting leaf is checked via Büchi reachability in $T_x$ (PTIME).
• Inclusion: $L(A) \subseteq L(B)$ reduced to a three-phase Rabin game built on the product $A \times \overline{B}$ (constant number of Rabin pairs, PTIME).

This demonstrates that core language-theoretic operations—consistency verification, emptiness, and inclusion—are tractable within this framework (Casares et al., 22 Jan 2026).

6. Congruence-Based Construction and Algebraic Theory

The canonical minimal consistent layered automaton $\Aatc(L)$ is constructed using a family of tuple congruences $\equiv_x$ over $x$-tuples of finite words, based on the concept of $x$-safe languages. For $x$-tuples $u = (u_1, \ldots, u_x)$,

$$(u_1,\dots,u_x) \equiv_x (v_1,\dots,v_x) \iff u_1 \cdots u_x \sim_L v_1 \cdots v_x \text{ and } \mathrm{Safe}_x(u) = \mathrm{Safe}_x(v)$$

where $\mathrm{Safe}_x(u)$ is the set of words $w$ such that $(u_1,\dots,u_{x-1}, u_x w) \not\equiv_x \bot$.

Each automaton layer is formed from the $\equiv_x$-classes of pointed tuples, with transitions corresponding to right-concatenation and parent maps merging tuple components. The resulting automaton is minimal, canonical, and its size is bounded polynomially in $|\Sigma|$, the number of layers, and the right congruence classes of $L$ (Casares et al., 22 Jan 2026).

7. Context: Relation to Implementation Paradigms

The concept of minimal consistent layered automata admits an effective symbolic implementation framework. In applications to regular languages (finite words), a two-layer system is employed:

• High Level: Normalized regular expressions structured for efficient derivative computation and normalization, yielding a finite number of syntactic derivatives (Charlier, 22 Sep 2025).
• Low Level: Hash-consed integer identifiers uniquely encoding normalized expressions, enabling $O(1)$ equality tests.
• Background Unification: Union–Find data structures and equation hashing merge equivalent expressions, ensuring minimality and unique state-language correspondence.

Such layering principles, when extended to infinite words via layered automata, ensure that large, complex sets of regular or omega-regular languages are uniformly and minimally represented, supporting efficient symbolic manipulation and statistical analysis (Charlier, 22 Sep 2025).