Active Automata Learning

• Active automata learning is a technique that uses active queries to infer finite-state models of unknown systems, underpinning black-box testing and verification.
• It extends classical frameworks like Angluin’s MAT model to accommodate richer models such as symbolic, timed, and register automata with adaptive query schemes.
• Practical implementations leverage observation tables, discrimination trees, and constraint solving to significantly reduce query costs and enhance real-world applicability.

Active automata learning is the area of automata theory focused on the algorithmic inference of finite-state models representing the behavior of unknown systems by means of active interaction, typically by issuing queries to a teacher or “oracle.” This paradigm is foundational for black-box system identification, model-based testing, protocol analysis, and formal synthesis. The field is characterized by the interplay of query strategies, representation formalisms, complexity theory, and advanced adaptations for richer classes of automata, optimization of sample complexity, and robustness to real-world constraints.

1. The Classical Angluin Framework and Extensions

The core of active automata learning is the Minimally Adequate Teacher (MAT) model, as formalized by Angluin (Hsiung et al., 2023). The system under learning (SUL) is modeled as a deterministic finite automaton, Mealy machine, Moore machine, or a related automata formalism: $M = (Q, q_0, \Sigma, \delta, L)$ where $Q$ is the finite state set, $q_0$ the initial state, $\Sigma$ the (finite) input alphabet, $\delta$ the transition function, and $L$ the output/acceptance labeling.

The classical MAT-learner interacts via two query types:

• Membership/membership-output/query: for a word $w$, the learner receives $f(w)$ or the output string $\lambda^*(q_0, w)$.
• Equivalence query: given a hypothesis automaton $H$, the teacher returns “yes” if $H \equiv M$ or a counterexample $c$ showing inequivalence.

The L* algorithm maintains an observation table indexed by sets $S$ and $E$ (prefixes and suffixes), closes and refines it iteratively, constructs hypotheses, and processes counterexamples—guaranteeing termination in polynomially many queries for regular targets (Hsiung et al., 2023, Vaandrager et al., 2021).

Extensions to richer models proceed by adapting query and representation schemes—for example:

• Moore/Mealy machines with output queries (Aichernig et al., 2022, Frohme, 2019).
• Markov decision processes (MDPs) with output-distribution queries (Tappler et al., 2019).
• Automata over infinite alphabets including symbolic automata (Hagedorn et al., 15 Nov 2025, Irie et al., 18 Sep 2025), or data automata (Garhewal et al., 2020, Frank et al., 17 Feb 2025).
• Timed automata and clock-constraint models (An et al., 2019, Xu et al., 2022, Teng et al., 2024, Waga, 2023).

2. Algorithmic Methodologies and Data Structures

Modern algorithms build on or depart from the tabular L*-style, employing a variety of core data structures and methodologies:

• Observation tables and discrimination trees: Used for tracking knowledge about state equivalence classes or separating suffixes (Aichernig et al., 2022, Frohme, 2019). For Mealy machines, discrimination trees efficiently manage equivalence classes via adaptive distinguishing sequences (ADS) (Frohme, 2019).
• Symbolic observation tables: For automata on infinite alphabets, cells correspond to (often Boolean-valued) variables, with constraints inferred via queries or observed system behavior; instantiations require constraint solving (e.g., SAT/SMT) (Hsiung et al., 2023, Hagedorn et al., 15 Nov 2025, Irie et al., 18 Sep 2025).
• Apartness-based observation trees: The $L^\#$ approach avoids explicit tables for Mealy machine learning, instead using tree-shaped partial automata and constructive “apartness” relations to drive state discovery (Vaandrager et al., 2021).
• Constraint and unification mechanisms: Especially in symbolic settings (e.g., REMAP), learned comparisons induce a dynamic constraint set $\mathcal C$ over variables, with unification, SAT/SAT-solving, and region/interval construction used to extract concrete automata (Hsiung et al., 2023).

Refinements such as counterexample-guided repair, efficient subtree replacement, and constraint pruning further improve performance and convergence (Frohme, 2019, Hsiung et al., 2023, Moeller et al., 18 Apr 2025).

3. Query Variants, Complexity, and Sample-Optimality

Active automata learning is governed by the complexity of query usage and guarantees on model identification:

• Exact identification: Under exact equivalence queries, e.g., REMAP provably achieves polynomial query complexity $O(n^2|\Sigma^I|^2)$ for preference queries and $O(n + |\Sigma^O|)$ equivalence queries, matching classical L* bounds (Hsiung et al., 2023).
• Rich query interfaces: For infinite alphabets, query strategies require learning symbolic partitions, often by binary or “piecewise” search (e.g., over $\mathbb Q$ via Stern–Brocot in symbolic automata) (Hagedorn et al., 15 Nov 2025); corresponding sample complexity matches information-theoretic lower bounds.
• Adaptive distinguishing sequences (ADS): Use of ADS in tests and discrimination reduces resets and sample steps by logarithmic or greater factors in many settings (Frohme, 2019, Vaandrager et al., 2021).
• Preference and PAC settings: Preference queries collect only inequalities/equalities among unknown outputs, requiring SAT-based concretization; PAC (Probably Approximately Correct) learning uses sampling-based equivalence queries to guarantee $\varepsilon$-approximate identification with high probability, with corresponding bounds on the number of steps (Hsiung et al., 2023).
• Empirical query counts: For realistic benchmarks (e.g., symbolic automata, timed, or NetKAT automata), observed query counts are often one to two orders of magnitude below tabular worst-case bounds due to symbolic compression, adaptive reuse, or test-suite reduction (Hagedorn et al., 15 Nov 2025, Irie et al., 18 Sep 2025, Moeller et al., 18 Apr 2025).

Summary tables of query complexity for various models and paradigms are as follows:

Model/Class	Query Complexity (membership)	Query Complexity (equivalence)	Reference
Classical DFA/Mealy	$O(n^2|\Sigma|)$	$O(n)$	(Vaandrager et al., 2021)
Symbolic automata ($\mathbb Q$)	$O(n^3\log m)$	$O(n^3)$	(Hagedorn et al., 15 Nov 2025)
REMAP with preference	$O(n^2|\Sigma|^2)$	$O(n + |\Sigma^O|)$	(Hsiung et al., 2023)
Timed automata (1-clock, smart teacher)	Poly$(n,|\Sigma|,C)$	Poly$(n,|\Sigma|,C)$	(An et al., 2019)
Symbolic Mealy	$O((n + m(n+k))(k+n))$	$O(n + k)$	(Irie et al., 18 Sep 2025)

4. Robustness, Adaptivity, and Real-World Aspects

Robustness to noise, non-determinism, and system evolution has motivated architectural adaptations:

• Conflict-aware learning: The C3AL/CEAL frameworks externalize the observation tree to robustly handle data conflicts arising from noise or mutations, triggering minimal learner restarts while maximizing query reuse. These approaches raise empirical success rates in noisy or evolving environments, while incurring minimal additional overhead (Ferreira et al., 2023).
• Passive vs. active paradigms: Practical studies on protocols (BLE, MQTT) confirm that passive (offline, log-based) inference typically requires an order of magnitude more data than active learning, with additional risk of missing states or failing exact reconstruction (Aichernig et al., 2022).
• Partial observability and advice: Extensions allow advisory mechanisms (e.g., string rewriting systems) to further reduce query count by deductive inference of membership and rapid counterexample filtering (Fica et al., 14 Aug 2025).
• Test suite minimization: Structural machine properties (inactive inputs, phase-dependence, component decomposition) are exploited to construct provably smaller test suites for equivalence/conformance queries, integrated via adaptive multi-armed bandit selection (Kruger et al., 2024).

5. Learning Rich and Infinite-State Models

Modern active learning encompasses symbolic, parametric, hybrid, and timed automata:

• Symbolic and register automata: Infinite alphabets or data domains are managed by learning transition guards (predicates), employing predicate learning via finite data as in L*-style, but with efficient partitioning and sample usage (Hagedorn et al., 15 Nov 2025, Garhewal et al., 2020, Irie et al., 18 Sep 2025).
• Timed automata: One-clock and multi-clock settings are handled via region partitioning (region graphs), with learning algorithms adapted to region-based symbolic observation tables and reset information tracking. When reset bits are unobservable and must be guessed, overall complexity becomes exponential in the number of clocks (An et al., 2019, Xu et al., 2022, Waga, 2023, Teng et al., 2024).
• Learning with comparative and preference feedback: REMAP demonstrates that automata can be precisely identified with only comparative information (preference queries) about the target function's outputs, generalizing the practical scope of active learning frameworks (Hsiung et al., 2023).
• Statistical and stochastic systems: L*-style frameworks for labeled MDPs and Mealy machines with stochastic delays support PAC-style convergence and efficiently separate the logical and quantitative parts of model inference (Tappler et al., 2019, Dengler et al., 22 Aug 2025).
• Bar and nominal automata: Infinite-alphabet models supporting name allocation and $\alpha$-equivalence can be learned by wrapping base finite-alphabet learners with appropriate equivalence-checking and symbolic preprocessing (Frank et al., 17 Feb 2025).

6. Empirical Evaluations and Tooling

Empirical evidence consistently demonstrates the scalability, competitiveness, and practicality of modern active automata learning:

• Benchmarks are drawn from protocol, hardware, Simulink controller models, NetKAT network images, and randomly generated symbolic automata (Hagedorn et al., 15 Nov 2025, Hsiung et al., 2023, Moeller et al., 18 Apr 2025, Irie et al., 18 Sep 2025).
• Metrics include query counts (membership/output, equivalence/preference), resets, conformance test steps, wall-clock time, and model isomorphism or regret with respect to ground truth.
• Summary findings: Usage of symbolic compression, adaptive test reductions, and robust information flow (e.g., conflict-aware trees) leads to substantial improvements—sometimes by 10–100$\times$—in total query cost and observed learning time as compared to baseline tabular approaches or unoptimized learners (see, e.g., (Ferreira et al., 2023, Irie et al., 18 Sep 2025, Moeller et al., 18 Apr 2025)).

Tool implementations such as LearnLib, wrappers for symbolic and register automata, and custom C++, OCaml, or Python-based prototypes have been widely adopted for both research and industrial model inference.

7. Connections, Open Directions, and Theoretical Frontiers

The active learning paradigm has evolved into a robust metatheory with guarantees spanning regular finite and infinite-state systems, symbolic data models, time and stochasticity, and practical robustness in black-box inference.

Open directions and research frontiers highlighted in the literature include:

• Generalization to non-deterministic, register, and richer automaton models, including nominal and data automata beyond equality (Garhewal et al., 2020, Frank et al., 17 Feb 2025).
• Cost-weighted and parallel test-generation strategies to minimize expensive interface operations (reset, conformance) (Frohme, 2019).
• Integration with deductive and passive inference (e.g., combining string-rewriting advice, logs) to synergistically reduce query overheads (Fica et al., 14 Aug 2025, Aichernig et al., 2022).
• Adaptive and multi-reference learning, leveraging background models and domain knowledge for rapid convergence (Kruger et al., 2024).
• Automata learning under adversarial noise, partial observability, or online system mutation, requiring further advances in data structure management, sample allocation, and interactive protocol design (Ferreira et al., 2023).

This rich area continues to unify theoretical computer science, formal methods, and practical systems analysis through automata-theoretic learning, with ongoing extensions in both expressive power and efficiency.