[Paper Review] Learning Product Automata

Joshua Moerman|arXiv (Cornell University)|May 8, 2017

Machine Learning and Algorithms3 citations

TL;DR

This paper proposes an optimization for active automata learning by decomposing Moore machines with multi-observable outputs into product automata, where each observable is learned independently. By exploiting structural decomposition, the method reduces query complexity—demonstrated to cut equivalence and membership queries by orders of magnitude in synthetic benchmarks—offering significant scalability improvements for learning complex software systems with compositional behavior.

ABSTRACT

In this paper we give an optimization for active learning algorithms, applicable to learning Moore machines where the output comprises several observables. These machines can be decomposed themselves by projecting on each observable, resulting in smaller components. These components can then be learnt with fewer queries. This is in particular interesting for learning software, where compositional methods are important for guaranteeing scalability.

Motivation & Objective

• To address the scalability bottleneck in active automata learning of complex software systems with multiple outputs.
• To exploit compositional structure in Moore machines by decomposing them into independent components based on output observables.
• To reduce the number of equivalence and membership queries required in learning, especially for systems with high-state-space complexity.
• To provide a practical, plug-compatible extension to existing learning algorithms like L* that supports product automata learning.
• To demonstrate the effectiveness of this decomposition in real-world and synthetic software models, particularly where components are nearly independent.

Proposed method

• The method decomposes a Moore machine with output in $O_1 \times O_2$ into two component machines $M_1$ and $M_2$, each with outputs in $O_1$ and $O_2$ respectively, such that the original machine is equivalent to their product $M_1 \times M_2$.
• It applies active learning (e.g., L*) independently to each component machine, using projection functions $\pi_i$ to extract the relevant output traces.
• The algorithm maintains separate hypotheses for each component and uses product construction to validate consistency via equivalence queries on the full product.
• It leverages the fact that if the components are independent, the total number of states in the components is $2\sqrt{|M|}$ in the best case, significantly less than $|M|$.
• It includes a reachability check on the product hypothesis to detect invalid outputs not in the allowed subset of $O_1 \times O_2$, enabling self-debugging without teacher interaction.
• The approach is integrated into a modified L* algorithm that alternates between learning components and validating the product, reducing overall query cost.

Experimental results

Research questions

• RQ1 Can decomposing a Moore machine with multi-observable output into independent components reduce the number of queries required in active automata learning?
• RQ2 How effective is component-wise learning of product automata compared to monolithic learning in terms of query efficiency and scalability?
• RQ3 What is the impact of component independence on the performance of the decomposition-based learning method?
• RQ4 Can the method be extended to handle constrained output sets where certain output combinations are forbidden?
• RQ5 Does the use of product decomposition outperform other structural optimizations, such as reverse automaton construction, in software model learning?

Key findings

• For the $n$-bit register machine, the product learner reduced equivalence queries from over 13,000 to just 22 for $n=7$, a reduction of over 99% compared to monolithic learning.
• On the $M_8$ machine with 2048 states, the product learner used 3,289 equivalence queries and 41,732 membership queries, compared to 160,000+ queries in the TTT learner, showing a 90%+ reduction in query cost.
• The method achieved a state-space reduction from $n \cdot 2^n$ states to $2\sqrt{n \cdot 2^n}$ in the best case, demonstrating exponential improvement in theoretical complexity.
• The $\text{mark1}$ circuit model showed a 70% reduction in equivalence queries and over 80% reduction in membership queries when using component learning.
• The key performance gain was observed only when components were nearly independent; for tightly coupled systems like $\text{keyb}$ and $\text{ex3}$, the improvement was minimal, indicating dependency is a critical factor.
• The method enabled self-debugging by detecting invalid output combinations in the product hypothesis, reducing reliance on the teacher for counterexamples.