Componentwise Automata Learning

• Componentwise automata learning is a methodology that decomposes a global automaton into smaller, manageable component models to reduce inference complexity.
• It includes variants for Moore and Mealy machines, synchronizing systems, and system integration, achieved by output projections and alphabet refinements.
• Learning architectures leverage active queries, enabling significant query savings by focusing on smaller state spaces and exploiting compositional structure.

Searching arXiv for the cited work and closely related papers on componentwise/compositional automata learning. Componentwise automata learning is a family of active automata learning techniques that exploits a target system’s compositional structure by learning smaller component models or projections and then reconstructing a global hypothesis. In the literature represented here, the approach appears in several technically distinct forms: componentwise learning of Moore machines with product-valued outputs, output-decomposed learning of Mealy machines, compositional learning of synchronizing parallel systems through automated alphabet refinement, and componentwise automata learning for system integration with direct component access (Moerman, 2017, Koenders et al., 2024, Henry et al., 23 Apr 2025, Fujinami et al., 6 Aug 2025). Across these variants, the shared objective is complexity reduction relative to monolithic learning, typically by replacing a single large inference problem with multiple smaller ones.

1. Conceptual scope and main variants

The core idea is to replace monolithic inference of a single automaton by inference of components that correspond either to output coordinates, observable projections, or local alphabets. In the Moore-machine setting, the output alphabet factors as a Cartesian product $O = O_1 \times \dots \times O_k$, and each projection $\pi_i$ yields a component machine $M_i$ that can be learned separately (Moerman, 2017). In the Mealy-machine setting, the decomposition is dual in the sense that it projects onto individual outputs; if $O=\{o_1,\dots,o_k\}$ is one-hot coded by $k$ bits, then each projection $\pi_j:O\to\{0,1\}$ yields a binary-output Mealy machine $M_j$ (Koenders et al., 2024).

A different line of work treats decomposition as a problem of recovering component alphabets for synchronizing systems. There, the target is an LTS over a global alphabet $\Sigma$, and a distribution $\mathcal D=\{\Sigma_1,\dots,\Sigma_n\}$ is refined during learning until it is consistent with global observations (Henry et al., 23 Apr 2025). Another setting arises in system integration, where the learner has direct access not only to the whole system but also to black-box components. In that setting, the target is a Moore machine network, and the distinguishing issue is not merely decomposition but also avoidance of learning component parts that never contribute to system-level behavior (Fujinami et al., 6 Aug 2025).

Work	Target formalism	Decomposition principle
"Learning Product Automata" (Moerman, 2017)	Moore machines	Product-valued outputs
"Output-decomposed Learning of Mealy Machines" (Koenders et al., 2024)	Mealy machines	Projections onto individual outputs
"Compositional Active Learning of Synchronizing Systems through Automated Alphabet Refinement" (Henry et al., 23 Apr 2025)	LTSs	Distributions of possibly overlapping component alphabets
"Componentwise Automata Learning for System Integration (Extended Version)" (Fujinami et al., 6 Aug 2025)	Moore machine networks	Direct component access with contextual redundancy removal

This suggests that “componentwise automata learning” is not a single algorithm but a methodological umbrella spanning several decomposition axes: outputs, observables, alphabets, and explicit system components.

2. Formal models and decomposition mechanisms

For Moore machines, a machine is a 6-tuple

$M = (Q,\Sigma,O,\delta,\lambda,q_0)$

with behavior $\pi_i$0 defined by $\pi_i$1. When $\pi_i$2, the projections $\pi_i$3 define component machines

$\pi_i$4

The original machine is equivalent to the product machine $\pi_i$5, although $\pi_i$6 may contain unreachable states; in a minimal realization one has $\pi_i$7 (Moerman, 2017).

For Mealy machines, a deterministic machine is given as

$\pi_i$8

with semantics $\pi_i$9. If $M_i$0 is one-hot coded by $M_i$1 bits, then for $M_i$2,

$M_i$3

and the $M_i$4-th projected machine is

$M_i$5

The full system is reconstructed from learned projections by synchronous product and re-assembly of the unique original output, with joint injectivity of $M_i$6 guaranteeing well-definedness (Koenders et al., 2024).

For synchronizing systems, the formalism is the labelled transition system

$M_i$7

Given local LTSs $M_i$8, synchronous parallel composition $M_i$9 uses the standard synchronous-on-shared, interleaving-on-local rule. A distribution of alphabets is a set of possibly overlapping subalphabets

$O=\{o_1,\dots,o_k\}$0

A language $O=\{o_1,\dots,o_k\}$1 is a product language over $O=\{o_1,\dots,o_k\}$2 if

$O=\{o_1,\dots,o_k\}$3

and the Prod-of-projections lemma states that this holds iff

$O=\{o_1,\dots,o_k\}$4

This establishes projection as the semantic basis of decomposition in the synchronous setting (Henry et al., 23 Apr 2025).

For system integration, each component is modeled as a deterministic Moore machine

$O=\{o_1,\dots,o_k\}$5

with partial transition function $O=\{o_1,\dots,o_k\}$6. Components are glued by a directed graph $O=\{o_1,\dots,o_k\}$7, producing a Moore machine network $O=\{o_1,\dots,o_k\}$8 whose global machine

$O=\{o_1,\dots,o_k\}$9

updates synchronously via

$k$0

Here decomposition is explicit in the system architecture rather than inferred from outputs or alphabets (Fujinami et al., 6 Aug 2025).

3. Learning architectures and query models

The classical baseline is Angluin-style active learning in the minimally adequate teacher model, using membership queries and equivalence queries. In the Moore-machine product setting, MQ returns the full tuple in $k$1, and EQ tests equivalence of a hypothesis to the target. A single observation table $k$2 is maintained, with

$k$3

and projections $k$4. The adapted criteria are product-closedness and product-consistency. If the table is product-closed and product-consistent, the usual quotient construction yields a candidate product machine whose $k$5-th component is exactly the minimal Moore automaton consistent with $k$6 (Moerman, 2017).

That same work also gives a parallel reduction to $k$7 independent learners. Each learner receives projected answers to membership queries, and once all learners propose hypotheses $k$8, the master forms $k$9 and poses a global equivalence query. Any returned counterexample is a counterexample in at least one projection and is fed back to the corresponding learner (Moerman, 2017).

The Mealy-machine variant, OL$\pi_j:O\to\{0,1\}$0, also maintains a single L$\pi_j:O\to\{0,1\}$1-style table $\pi_j:O\to\{0,1\}$2, but $\pi_j:O\to\{0,1\}$3 records full Mealy outputs and is projected to $\pi_j:O\to\{0,1\}$4 for each output bit. The central defects are output-closure, output-consistency, and component-consistency. When a defect is found, the algorithm adds either a new prefix to $\pi_j:O\to\{0,1\}$5 or a new suffix to $\pi_j:O\to\{0,1\}$6, refills the table by MQs, and repeats. Its pseudocode initializes $\pi_j:O\to\{0,1\}$7, $\pi_j:O\to\{0,1\}$8, fills $\pi_j:O\to\{0,1\}$9 by MQs, repairs projected defects, builds provisional hypotheses $M_j$0, checks “exactly-one-1,” composes $M_j$1, and asks $M_j$2. In practice, checks for different $M_j$3 are interleaved and table repairs are chosen greedily by a greedy hitting-set approximation (Koenders et al., 2024).

CoalA interleaves two loops. In the local-learning loop, for each current subalphabet $M_j$4, a standard active learner runs on $M_j$5, translating local membership queries to global queries by uplift if possible. In the global-equivalence loop, the composite hypothesis

$M_j$6

is checked against the Teacher. If a counterexample arrives and $M_j$7, then the counterexample is or immediately yields a distribution-counterexample, from which one extracts minimal discrepancy sets $M_j$8 and updates $M_j$9, optionally canonizing and restarting local learners. Otherwise, the counterexample is local and its projections are forwarded to learners (Henry et al., 23 Apr 2025).

CCwL$\Sigma$0 for system integration runs concurrent L$\Sigma$1-style learners—one per component—but uses only system-level EQ and combines this with context analysis. The learner has access to system-level oracles $\Sigma$2 and $\Sigma$3, as well as component-level oracles $\Sigma$4 and $\Sigma$5. The algorithm builds a hypothesis network from component tables, performs 1Ext completeness queries, and analyzes global counterexamples via contextual variants of 1Ext and AnalyzeCex$\Sigma$6, parameterized by CA-parameters $\Sigma$7 (Fujinami et al., 6 Aug 2025).

4. Reconstruction, correctness, and complexity

Reconstruction is explicit in both the Moore and Mealy projection settings. For Moore machines with product outputs, the global machine is equivalent to the product of the learned component machines, modulo unreachable states in the Cartesian product (Moerman, 2017). For Mealy machines, if each projected learner returns

$\Sigma$8

then the reconstructed machine has state space

$\Sigma$9

initial state $\mathcal D=\{\Sigma_1,\dots,\Sigma_n\}$0, synchronous transition function, and output assembled as the unique $\mathcal D=\{\Sigma_1,\dots,\Sigma_n\}$1 whose projections match the component outputs. One shows $\mathcal D=\{\Sigma_1,\dots,\Sigma_n\}$2, and in fact only the reachable part of the product is used (Koenders et al., 2024).

The query-complexity rationale for componentwise learning is that smaller components can make $\mathcal D=\{\Sigma_1,\dots,\Sigma_n\}$3 much smaller than $\mathcal D=\{\Sigma_1,\dots,\Sigma_n\}$4. For monolithic L$\mathcal D=\{\Sigma_1,\dots,\Sigma_n\}$5 on a Moore machine of size $\mathcal D=\{\Sigma_1,\dots,\Sigma_n\}$6, standard bounds give $\mathcal D=\{\Sigma_1,\dots,\Sigma_n\}$7 membership queries and $\mathcal D=\{\Sigma_1,\dots,\Sigma_n\}$8 equivalence queries. If each component $\mathcal D=\{\Sigma_1,\dots,\Sigma_n\}$9 is learned separately, the total cost becomes

$M = (Q,\Sigma,O,\delta,\lambda,q_0)$0

and if the states factor as $M = (Q,\Sigma,O,\delta,\lambda,q_0)$1 with $M = (Q,\Sigma,O,\delta,\lambda,q_0)$2, then $M = (Q,\Sigma,O,\delta,\lambda,q_0)$3 is exponentially smaller than $M = (Q,\Sigma,O,\delta,\lambda,q_0)$4 once $M = (Q,\Sigma,O,\delta,\lambda,q_0)$5 (Moerman, 2017).

For output-decomposed Mealy learning, standard L$M = (Q,\Sigma,O,\delta,\lambda,q_0)$6 for $M = (Q,\Sigma,O,\delta,\lambda,q_0)$7 with $M = (Q,\Sigma,O,\delta,\lambda,q_0)$8 asks $M = (Q,\Sigma,O,\delta,\lambda,q_0)$9 membership queries and $\pi_i$00 EQs. OL$\pi_i$01 asks, in the worst case,

$\pi_i$02

with the note that in practice only 1 EQ is used on the composed $\pi_i$03. The structural assumption is that a substantial gain arises when the original machine is “one-hot” in its outputs or more generally exhibits a product-like structure in $\pi_i$04, so that each $\pi_i$05 drastically reduces the number of distinguishable states. Conversely, if some projection still needs $\pi_i$06 states, no improvement is gained (Koenders et al., 2024).

CoalA’s correctness argument has two parts: termination of local learners for any fixed distribution by standard active-learning convergence, and termination of distribution refinement because each update strictly increases a finite preorder on distributions. The algorithm therefore terminates and returns hypotheses whose synchronous composition is equivalent to the unknown SUL. Its complexity discussion is intentionally rough: in the worst case one may refine up to $\pi_i$07 subsets, but in practice far fewer, and the total number of membership queries is typically orders of magnitude smaller than monolithic learning over $\pi_i$08 (Henry et al., 23 Apr 2025).

CCwL$\pi_i$09 states an explicit theorem for the sound case. If $\pi_i$10, $\pi_i$11 is any component abstraction, the true network has in total $\pi_i$12 states summed over components, input alphabet size $\pi_i$13, and maximum counterexample length $\pi_i$14, then CCwL$\pi_i$15 uses at most

$\pi_i$16

component-level output queries and $\pi_i$17 system-level equivalence queries. Unsound $\pi_i$18 may add at most $\pi_i$19 extra queries, but does not affect termination (Fujinami et al., 6 Aug 2025).

5. Empirical results and application domains

The empirical literature shows that the effectiveness of componentwise learning is strongly structure-dependent. In "Learning Product Automata," the motivating applications are software and protocol components exposing multiple observables such as “status” and “error-code,” or several output pins of a hardware port. The paper states that if these observables evolve largely independently, one can learn each projection with far fewer queries than the monolithic product. It also reports that empirical results on $\pi_i$20-bit “register-machines” show a drop from $\pi_i$21 MQ to $\pi_i$22, described as “from exponential to polynomial in $\pi_i$23” (Moerman, 2017).

The Mealy-machine study reports preliminary experiments in LearnLib on two benchmark suites. For artificial random interleavings with dedicated outputs, machines were built by “activating” one of $\pi_i$24 small sub-machines on inputs $\pi_i$25, each sub-machine having its own disjoint output set; full machine size reached up to 10 000 states while projections summed to only $\pi_i$26 states, and OL$\pi_i$27 reduced membership-query symbols by up to two orders of magnitude compared to standard L$\pi_i$28. On the Labbaf et al. (2023) benchmark, the machines arise from parallel interleavings of components that share output symbols; because outputs are not one-hot, OL$\pi_i$29 cannot decompose, and indeed it performs worse than L$\pi_i$30 (Koenders et al., 2024).

CoalA’s evaluation spans more than 630 subject systems. On 300 random LTSs with various concurrency patterns, CoalA used up to $\pi_i$31–$\pi_i$32 fewer membership queries than monolithic L$\pi_i$33 and roughly $\pi_i$34 fewer equivalence queries in highly concurrent cases. On two large industrial-style models, CloudOpsManagement and a producer/consumer net, the implementation scales to systems with thousands of states, with query complexity close to an idealized compositional baseline with known decomposition. On more sequential Petri-net-derived examples, it still learns correctly but the query savings are smaller, as expected when concurrency is limited (Henry et al., 23 Apr 2025).

The system-integration work compares MnL$\pi_i$35, CwL$\pi_i$36, and CCwL$\pi_i$37 on random benchmarks, MQTT, and $\pi_i$38. The metrics are learned states and transitions, number of OQ resets and steps, EQ resets and steps, learner CPU time, and validation success/failure/timeouts. In all benchmarks, MnL$\pi_i$39 quickly times out on larger networks; CwL$\pi_i$40 learns all components fully, incurring large tables for redundant parts; and CCwL$\pi_i$41 with $\pi_i$42 consistently yields the smallest models and fewest queries, at a moderate learner-side cost. On RichComp and MQTT, CCwL$\pi_i$43 reduces component sizes by $\pi_i$44, OQ queries by $\pi_i$45, and EQs by $\pi_i$46, compared to CwL$\pi_i$47 (Fujinami et al., 6 Aug 2025).

These findings support a consistent interpretation: componentwise methods are most effective when the decomposition exposes smaller state spaces or excludes behavior that is irrelevant at the system level.

6. Limitations, misconceptions, and open directions

A persistent misconception is that decomposition automatically yields savings. The cited work repeatedly rejects that conclusion. In the output-decomposed Mealy setting, if outputs are shared by components, projections do not shrink the machine and OL$\pi_i$48 can even incur extra cost because of extra consistency checks; the paper’s Labbaf-benchmark result is a direct example (Koenders et al., 2024). In the Moore-machine product setting, if outputs are strongly correlated, the individual learners may not save queries, and intermediate global hypotheses $\pi_i$49 can have many unreachable states, which some equivalence-oracles struggle with (Moerman, 2017).

A second misconception is that the decomposition is always known a priori. The literature is divided on this point. Product-output and output-projection methods assume a meaningful projection structure from the start. CoalA explicitly addresses the case of unknown decomposition by starting from singleton alphabets and refining them through discrepancy sets derived from distribution-counterexamples. The paper also notes that greedy discrepancy selection may not always yield the smallest final distribution, and finding optimal refinements remains open (Henry et al., 23 Apr 2025). In the Mealy setting, finding the “best” output decomposition beyond one-hot may be computationally hard (Koenders et al., 2024).

A third issue concerns access assumptions. Earlier compositional work often assumes only global teacher access; the system-integration setting changes this by giving the learner direct access to black-box components through component-level output queries. That setting introduces “component redundancies,” meaning states or transitions that can never appear under any global execution. CCwL$\pi_i$50 addresses this by over-approximating reachable global configurations of the current hypothesis through reachability analysis $\pi_i$51 on the quotiented network $\pi_i$52. The abstraction choices include $\pi_i$53, $\pi_i$54, and $\pi_i$55; the reachability bounds include $\pi_i$56 and $\pi_i$57. When $\pi_i$58 is sound, no reachable input to any component is missed; unsound choices merely add extra refinements (Fujinami et al., 6 Aug 2025).

The open directions identified in the literature are technically aligned. The Mealy paper references using TTT instead of L$\pi_i$59 for smaller tables, combining input- and output-decomposition for even larger gains, and allowing component-wise EQs in the teacher model (Koenders et al., 2024). The system-integration work points to large alphabet and symbolic methods, as well as application to real-world SI pipelines (Fujinami et al., 6 Aug 2025). CoalA highlights extensions to richer models such as register automata and timed automata, and to other query frameworks such as apartness-based learning (Henry et al., 23 Apr 2025).

Taken together, these directions indicate that componentwise automata learning has evolved from fixed output-factorization in product automata to automated decomposition discovery and context-sensitive pruning, while retaining the central premise that scalability depends on exposing a decomposition that meaningfully reduces the effective hypothesis space.