Pith. sign in

REVIEW 3 major objections 8 minor 30 references

Extending AALpy with Passive Learning: A Generalized State-Merging Approach

T0 review · 3 major / 8 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read A single generalized state-merging loop in AALpy covers deterministic, observably nondeterministic, and probabilistic IO automata with Mealy or Moore output.

desk verdict A well-engineered tool paper that delivers a genuinely general state-merging framework for AALpy; the empirical section is thin and the structural invariants are asserted, but the core capability claim is credible. read the letter →

arxiv 2506.06333 v2 pith:UZJRYQNJ submitted 2025-05-31 cs.LG cs.FL

Benjamin von Berg , Bernhard K. Aichernig This is my paper
classification cs.LGcs.FL
keywords automatalearningmodelinferencepassivestatemergingred-blueframeworkIOprobabilisticAALpy
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper reports a new passive-learning component in the automata-learning library AALpy: one configurable implementation of state merging in the red-blue framework. The authors claim that by building the implementation on a common internal representation, an IO frequency automaton that records how often each transition was observed, this single loop can learn deterministic, observably nondeterministic (the target state is unique once the emitted output is known), and probabilistic automata with either Mealy output (output tied to the transition) or Moore output (output tied to the state). Expressing an algorithm then reduces to defining a local compatibility check and a scoring function. They show that known algorithms such as RPNI, evidence-driven state merging (EDSM), and IOAlergia can be instantiated in a few lines of code, and that the implementation is practical, learning DFAs with over a thousand states from hundreds of thousands of traces in minutes. If the claim is right, researchers get a single place to prototype new state-merging algorithms and to inject domain knowledge into existing ones.

What carries the argument

The central object is the IO frequency automaton (IOFA), an automaton whose transitions carry observation counts, used as the single internal representation from which every supported automaton type is extracted. It carries the argument by letting one merge loop handle all cases: deterministic and Moore behavior are enforced as local invariants during merging, and probabilistic behavior is obtained by normalizing the frequency counts. The loop itself is the red-blue framework, parameterized by a node order, a local compatibility function, and a scoring function, with an optional stateful score object that accumulates evidence during compatibility checks.

What would settle it

Run the framework on small prefix trees while comparing its greedy merge order against an exhaustive search over all merge orders; if any run returns an automaton whose transition or output behavior differs from the requested type, or a model larger than one reachable by a legal merge order, the local-invariant assumption fails. A concrete test is a two-branch PTA whose branches share a suffix, configured with a node order that forces early rejection of a merge that becomes deterministic only after the suffix is merged.

Watch

Extended reading notes

Core claim

The paper's central claim is that the red-blue state-merging framework can be generalized over a common internal representation, the IO frequency automaton (IOFA), which records how often each transition was observed. All supported automaton types—deterministic, observably nondeterministic, and probabilistic transition behavior, crossed with Mealy or Moore output—are extracted from this one representation, while structural properties are enforced during merging by rejecting candidates that would locally violate them. As a result, defining a state-merging algorithm in the library mainly means writing a compatibility criterion and a scoring function; the same implementation reproduces RPNI, evidence-driven state merging (EDSM), IOAlergia, and a likelihood-ratio method, and also permits custom variants such as parity-based domain constraints and noise-tolerant deterministic learning.

Load-bearing premise

The load-bearing premise is that the local structural checks in Section 2.3 are complete: rejecting a merge that would make the current intermediate automaton violate Moore behavior, determinism, or the requested probabilistic form is enough to guarantee the final automaton has the requested type, and no valid merge is ever blocked that would only become admissible after further merging.

Editorial extensions

If this is right

  • Existing state-merging algorithms such as RPNI, EDSM, and IOAlergia can be re-expressed in the framework with only a few lines of code, making side-by-side comparison a matter of swapping functions.
  • New algorithms for deterministic, observably nondeterministic, or probabilistic IO automata can be built by supplying a compatibility check and a score, without reimplementing the merge loop.
  • Domain knowledge can be injected as an additional local compatibility criterion, as demonstrated by a parity-based constraint that keeps apart states with different physical configurations of a car alarm system.
  • The implementation is fast enough for practical use, reportedly learning DFAs with well over a thousand states from several hundred thousand traces in a few minutes.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Editorial extension: the 'algorithm equals compatibility plus score' pattern suggests that the next generation of state-merging research could focus on designing reusable compatibility and scoring components, in the way that kernels and losses are treated in other learning frameworks.
  • Editorial extension: the paper's stated plan to combine active and passive learning could be tested immediately by routing actively collected queries into the same merge loop, reusing the library's existing active learners as trace generators.
  • Editorial extension: because the structural invariants are checked only locally, a fuzz test that compares the requested automaton type with the returned type on random small prefix trees would be a cheap way to probe whether the completeness assumption in Section 2.3 holds in practice.
  • Editorial extension: the stateful scoring pattern opens the door to evidence-aware statistical tests, such as EDSM-style evidence counts accumulated over Hoeffding-based compatibility checks, which the paper sketches but does not fully evaluate.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 8 minor

Summary. The paper reports on a new passive-learning component added to AALpy. The component implements the red-blue state-merging framework once, over a common IO frequency automaton (IOFA) representation, and exposes two configuration dimensions: output behavior (Mealy vs. Moore) and transition behavior (deterministic, observably nondeterministic, or stochastic). The user supplies local compatibility and scoring functions through the ScoreCalculation class, and the run method converts the learned IOFA to the requested automaton class. The paper gives example instantiations for RPNI, EDSM, IOAlergia, several IOAlergia variants, domain-knowledge injection, and a noise-tolerant deterministic learner, and demonstrates these on a car-alarm example with 200 traces.

Significance. The contribution is primarily engineering: a single generalized implementation is intended to reduce the effort needed to prototype state-merging algorithms across six automaton classes, and the examples show that several existing algorithms can be expressed in a few lines. The library is open source and the artifact is marked reusable, so this is a plausible and potentially useful resource for the automata-learning community. The paper does not claim new algorithmic results, and none are needed; the value depends on the correctness of the structural-enforcement invariants in Section 2.3, on the usability of the API, and on the reproducibility of the demonstration. Those three points are not fully established in the manuscript, which is why my recommendation is major revision rather than acceptance.

major comments (3)
  1. [Section 2.3] The central invariant claim is stated rather than demonstrated. The text says that Moore behavior 'can be turned into an invariant of state-merging by strengthening the local compatibility criterion' and that deterministic transition behavior is enforced 'analogously,' but it never defines the exact checks performed on a merge candidate, how implied merges are checked, or why a locally consistent merge cannot later produce a global violation (for example, a Moore output conflict that only becomes visible after additional merges). Because the coverage claim in the abstract and Section 1 depends on the framework returning automata of the requested output and transition type, this needs either a proof of the invariant relative to the merge closure in Algorithm 1 or a systematic invariant test in the artifact (for example, checking the output_behavior and transition_behavior of every intermediate and final model across all examples and random instances). The monotonicity of merging makes the invariant plausible, but the burden should not be left on the reader.
  2. [Appendix, 'Comparison of Examples'] The sample-efficiency claims rest on a single run using 200 traces with lengths chosen uniformly from [10,20], no seeds, and no repetitions. The text reports qualitative observations ('off by only one state', 'has been merged too aggressively') without a quantitative error metric, a baseline such as RPNI on the same data, or a statement about variance. Since Figure 4 is the only empirical evidence in the paper, the claims that the algorithms 'can learn models ... up to sampling error' and the relative comparison between variants need repeated trials, a summary statistic or confidence interval, and a precise description of the trace-generation procedure (random seed, input distribution, and number of runs).
  3. [Section 2.1, Definition 4 and Section 2.3] The formal definition of IOFA does not state the relationship between the frequency function ν and the transition function δ. As written, ν: Q × I × O → N is independent of δ, so it is unclear whether ν can be positive for an input/output pair for which δ is undefined. The normalization formula in Section 2.3 sums over all outputs o' ∈ O and is undefined when Σ ν(q, i, o') = 0 for an input that has never been observed from q. The paper should require ν(q, i, o) = 0 whenever δ(q, i, o) is undefined and should define the probability for unobserved inputs as 0 or leave the transition undefined. This matters directly for the probabilistic automaton classes that the framework claims to support and for the IOAlergia compatibility code in Example 5, which relies on counts being zero exactly for absent transitions.
minor comments (8)
  1. [Section 2.2] The sentence 'This section, gives a brief overview' contains an extra comma, and 'partitioningresulting' is missing a space; these should be corrected.
  2. [Section 3.1] The text says 'breath first' where 'breadth first' is meant, and the description of consider_only_min_blue says it 'restricts the set of merge candidates to pairs of red states with the minimal blue node'; this should be 'to red-blue pairs involving the minimal blue node.'
  3. [Section 2.1] The informal treatment of the initial Moore output as a transition ⟨ϵ, ϵ, o0, q0⟩ should be flagged as a representational convention, since ϵ is not an element of I or O and Definition 2 would otherwise count this transition when checking determinism.
  4. [Section 3.1, Example 5] The example uses the function hoeffding_compat without defining it or giving a reference; if it is a library helper, provide a pointer to its implementation and specify the exact Hoeffding bound and how the parameter ε is used.
  5. [Section 3.1] The sentence 'The values True and False correspond to a score of positive and negative infinity' is confusing because the preceding sentences describe score_function as returning 'some form of score'; clarify that Boolean return values are overloaded to mean immediate acceptance and rejection, respectively.
  6. [Appendix, Example 9] The expression 1 - binom.cdf(mismatches - 1, total_count, error_rate) is not defined for mismatches = 0, since the CDF argument would be -1; add a guard for the zero-mismatch case or use the survival function with the correct convention.
  7. [Section 4] The performance comparison with LearnLib reports slowdown factors of 7.24 and 6.3 but gives no hardware details, JVM version, dataset sizes, or number of repetitions; these details are needed to interpret the 'sufficiently fast for practical applications' claim.
  8. [Appendix, Figure 4] The captions do not state that labels such as 'd:0.1344' are estimated transition probabilities, nor how probabilities are rounded; add a sentence explaining the notation.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the work implements and evaluates established state-merging algorithms against external benchmarks, and its self-citations are background references, not load-bearing derivations.

full rationale

The paper's central claim is that a generalized red-blue state-merging implementation, built on IOFA, covers deterministic, observably nondeterministic, and probabilistic IO automata with Mealy or Moore behavior, so that defining algorithms reduces to compatibility and scoring functions. This is a software-engineering and coverage claim, not a predictive derivation from fitted inputs. No quantity is fitted to data and then reported as a prediction; the learned automata are outputs of standard algorithms (RPNI, EDSM, IOAlergia, custom variants) evaluated on benchmark data such as Abbadingo (Section 4: 'our implementation is slower than LearnLib by a factor of 7.24' for RPNI on Abbadingo training data). The self-citation [18] for AALpy and [4] for hierarchical learning are background or future-work references; neither is invoked to justify the new framework's correctness or to forbid alternatives. The only identified weakness, the invariant argument in Section 2.3 that local rejections preserve Moore and deterministic structure, is asserted without a formal proof or invariant tests. That is a completeness or correctness risk, not circularity: the claim does not reduce to its own inputs by definition, and the monotonically additive nature of merging is an independent, checkable property rather than a fitted parameter. The framework is self-contained against external algorithms and benchmarks, so the honest finding is no significant circularity (score 0).

Assumptions & free parameters 3 free parameters · 3 assumptions · 0 invented entities

The central claim is a software architecture claim rather than a derivation, so the ledger contains no fitted scientific constants and no invented entities. The framework's expressive power borrows the red-blue framework and the observable nondeterminism restriction from prior theory; the listed hyperparameters are user-facing knobs for the illustrative experiments and do not support the central claim by being fit to it.

free parameters (3)
  • epsilon (IOAlergia) = 0.05 (default)
    Hand-chosen default for the Hoeffding compatibility bound in the appendix examples; not fitted to data or to the target car-alarm model.
  • error_rate (noisy-data example) = 0.01 (hand-estimated)
    Per-step mislabeling rate in Example 9, 'roughly estimated' by the authors across states; user-set, not derived from data.
  • significance threshold = 0.05
    Threshold for accepting or rejecting merges in Example 9; user-set.
assumptions (3)
  • domain assumption All supported automata are observably nondeterministic: the reached state is uniquely determined by the current state, input, and observed output (Assumption 3).
    Introduced in Section 2.1 as Assumption 3; it justifies the PTA and implied merges, and excludes more expressive models (EFSMs), which the paper acknowledges in Section 4.
  • standard math The red-blue framework from Lang et al. [15] is a correct and terminating basis for state merging; iteratively merging red-blue pairs with implied merges yields a valid generalization of the traces.
    Taken as background in Section 2.2; the paper does not re-derive correctness or termination, and this is standard literature.
  • standard math The prefix tree automaton (PTA) with frequencies represents exactly the observed traces and no other behavior.
    Assumed in Section 2.2; standard for state-merging algorithms, and the basis for all subsequent inference.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Extending AALpy with Passive Learning: A Generalized State-Merging Approach." pith.science (2026). https://pith.science/paper/UZJRYQNJ

@misc{pith2026250606333,
  author       = {Pith},
  title        = {Pith review of: Extending AALpy with Passive Learning: A Generalized State-Merging Approach},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/UZJRYQNJ}},
  note         = {Machine review of arXiv:2506.06333}
}
read the original abstract

AALpy is a well-established open-source automata learning library written in Python with a focus on active learning of systems with IO behavior. It provides a wide range of state-of-the-art algorithms for different automaton types ranging from fully deterministic to probabilistic automata. In this work, we present the recent addition of a generalized implementation of an important method from the domain of passive automata learning: state-merging in the red-blue framework. Using a common internal representation for different automaton types allows for a general and highly configurable implementation of the red-blue framework. We describe how to define and execute state-merging algorithms using AALpy, which reduces the implementation effort for state-merging algorithms mainly to the definition of compatibility criteria and scoring. This aids the implementation of both existing and novel algorithms. In particular, defining some existing state-merging algorithms from the literature with AALpy only takes a few lines of code.

Figures

Figures reproduced from arXiv: 2506.06333 by the authors.

Figure 1
Figure 1. Example of a PTA without frequencies (left) and the partitioning resulting [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Intermediate steps of state merging in the red-blue framework. [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 3
Figure 3. Car alarm systems with deterministic (??) and probabilistic (??) behav￾ior. 3 Usage 3.1 Defining and Running State-Merging Algorithms To define a state-merging algorithm, the GeneralizedStateMerging class is instantiated. Its most important parameters are: output_behavior: Defines whether an automaton with Moore or Mealy behav￾ior should be learned and adds corresponding restrictions for local compati￾bility. Possib… view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Learned models of the faulty car alarm system using different algorithms [PITH_FULL_IMAGE:figures/full_fig_p016_4.png]
Figure 4
Figure 4. Figure 4: Learned models of the faulty car alarm system using different algorithms [PITH_FULL_IMAGE:figures/full_fig_p017_4.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

30 extracted references · 19 canonical work pages

  1. [1]

    In: Gi- annakopoulou, D., Méry, D

    Aarts, F., Heidarian, F., Kuppens, H., Olsen, P., Vaandrager, F.W.: Au- tomata learning through counterexample guided abstraction refinement. In: Gi- annakopoulou, D., Méry, D. (eds.) FM 2012: Formal Methods - 18th International Symposium, Paris, France, August 27-31, 2012. Proceedings. Lecture Notes in Computer Science, vol. 7436, pp. 10–27. Springer (20...

    work page 2012

  2. [2]

    Formal Methods Syst

    Aichernig, B.K., Tappler, M.: Probabilistic black-box reachability check- ing (extended version). Formal Methods Syst. Des.54(3), 416–448 (2019). https://doi.org/10.1007/S10703-019-00333-0,https://doi.org/10.1007/ s10703-019-00333-0

    doi:10.1007/s10703-019-00333-0 2019

  3. [3]

    In: Egyed, A., Wimmer, M., Chechik, M., Combemale, B

    Ayoughi, N., Nejati, S., Sabetzadeh, M., Saavedra, P.: Enhancing automata learn- ing with statistical machine learning: A network security case study. In: Egyed, A., Wimmer, M., Chechik, M., Combemale, B. (eds.) Proceedings of the ACM/IEEE 27th International Conference on Model Driven Engineering Languages and Sys- tems, MODELS 2024, Linz, Austria, Septem...

    arXiv 2024

  4. [4]

    In: Madeira, A., Knapp, A

    von Berg, B., Aichernig, B.K., Rindler, M., Stern, D., Tappler, M.: Hierarchi- cal learning of generative automaton models from sequential data. In: Madeira, A., Knapp, A. (eds.) Software Engineering and Formal Methods - 22nd Inter- national Conference, SEFM 2024, Aveiro, Portugal, November 6-8, 2024, Proceed- ings. Lecture Notes in Computer Science, vol....

    work page doi:10.1007/978-3-031-77382-2_13 2024

  5. [5]

    A Framework for Streaming Event-Log Prediction in Business Processes

    Bollig, B., Függer, M., Nowak, T.: A framework for streaming event-log predic- tion in business processes. CoRRabs/2412.16032(2024).https://doi.org/10. 48550/ARXIV.2412.16032

    work page Pith review arXiv doi:10.48550/arxiv.2412.16032 2024

  6. [6]

    In: Touili, T., Cook, B., Jackson, P.B

    Bollig, B., Katoen, J., Kern, C., Leucker, M., Neider, D., Piegdon, D.R.: libalf: The automata learning framework. In: Touili, T., Cook, B., Jackson, P.B. (eds.) Com- puter Aided Verification, 22nd International Conference, CAV 2010, Edinburgh, UK, July 15-19, 2010. Proceedings. Lecture Notes in Computer Science, vol. 6174, pp. 360–364. Springer (2010).ht...

    doi:10.1007/978-3-642-14295-6_32 2010

  7. [7]

    Cassel, S., Falk, H., Jonsson, B.: RALib : A LearnLib extension for inferring EFSMs. In: International Workshop on Design and Implementation of Formal Tools and Systems, DIFTS 2015, Austin, TX, USA, September 26-27 (2015), https://api.semanticscholar.org/CorpusID:12915995

    work page 2015

  8. [8]

    In: Mutzel, P., Jünger, M., Leipert, S

    Ellson, J., Gansner, E.R., Koutsofios, E., North, S.C., Woodhull, G.: Graphviz - open source graph drawing tools. In: Mutzel, P., Jünger, M., Leipert, S. (eds.) Graph Drawing, 9th International Symposium, GD 2001 Vienna, Austria, Septem- ber 23-26, 2001, Revised Papers. Lecture Notes in Computer Science, vol. 2265, pp. 483–484. Springer (2001).https://doi...

    doi:10.1007/3-540-45848-4_57 2001

Show all 30 references
  1. [9]

    In: Neele, T., Wijs, A

    Ganty, P.: Learning the state machine behind a modal text editor: The (neo)vim case study. In: Neele, T., Wijs, A. (eds.) Model Checking Software - 30th Inter- national Symposium, SPIN 2024, Luxembourg City, Luxembourg, April 8-9, 2024, Proceedings. Lecture Notes in Computer S...

    2024 doi

  2. [10]

    Cambridge University Press (2010).https://doi.org/10.1017/ CBO9781139194655 Extending AALpy with Passive Learning 19

    de la Higuera, C.: Grammatical Inference: Learning Automata and Gram- mars. Cambridge University Press (2010).https://doi.org/10.1017/ CBO9781139194655 Extending AALpy with Passive Learning 19

    2010

  3. [11]

    In: Kroening, D., Pasareanu, C.S

    Isberner, M., Howar, F., Steffen, B.: The open-source learnlib - A framework for active automata learning. In: Kroening, D., Pasareanu, C.S. (eds.) Com- puter Aided Verification - 27th International Conference, CAV 2015, San Fran- cisco, CA, USA, July 18-24, 2015, Proceedings,...

    2015

  4. [12]

    In: Jansen, N., Stoelinga, M., van den Bos, P

    Junges, S., Rot, J.: Learning language intersections. In: Jansen, N., Stoelinga, M., van den Bos, P. (eds.) A Journey from Process Algebra via Timed Automata to Model Learning - Essays Dedicated to Frits Vaandrager on the Occasion of His 60th Birthday. Lecture Notes in Compute...

    2022 doi

  5. [13]

    In: Platzer, A., Rozier, K.Y., Pradella, M., Rossi, M

    Kobialka,P.,Pferscher,A.,Bergersen,G.R.,Johnsen,E.B.,Tarifa,S.L.T.:Stochas- tic games for user journeys. In: Platzer, A., Rozier, K.Y., Pradella, M., Rossi, M. (eds.) Formal Methods - 26th International Symposium, FM 2024, Milan, Italy, September 9-13, 2024, Proceedings, Part ...

    2024

  6. [14]

    Kuze, N., Seno, K., Ushio, T.: Learning-based black box checking for k-safety hyperproperties. Eng. Appl. Artif. Intell.126, 107029 (2023).https://doi.org/ 10.1016/J.ENGAPPAI.2023.107029

    2023

  7. [15]

    In: Honavar, V.G., Slutzki, G

    Lang, K.J., Pearlmutter, B.A., Price, R.A.: Results of the Abbadingo One DFA learning competition and a new evidence-driven state merging algorithm. In: Honavar, V.G., Slutzki, G. (eds.) Grammatical Inference, 4th International Collo- quium, ICGI-98, Ames, Iowa, USA, July 12-1...

    1998

  8. [16]

    Mao, H., Chen, Y., Jaeger, M., Nielsen, T.D., Larsen, K.G., Nielsen, B.: Learning deterministic probabilistic automata from a model checking perspective. Mach. Learn.105(2), 255–299 (2016).https://doi.org/10.1007/s10994-016-5565-9

    2016 doi

  9. [17]

    In: 29th IEEE International Conference on Emerging Technologies and Factory Automation, ETFA 2024, Padova, Italy, September 10-13, 2024

    Moddemann, L., Steude, H.S., Diedrich, A., Pill, I., Niggemann, O.: Extracting knowledge using machine learning for anomaly detection and root-cause diagnosis. In: 29th IEEE International Conference on Emerging Technologies and Factory Automation, ETFA 2024, Padova, Italy, Sep...

    2024

  10. [18]

    Muskardin, E., Aichernig, B.K., Pill, I., Pferscher, A., Tappler, M.: Aalpy: an active automata learning library. Innov. Syst. Softw. Eng.18(3), 417–426 (2022). https://doi.org/10.1007/S11334-022-00449-3

    2022 doi

  11. [19]

    In: ter Beek, M.H., Monahan, R

    Muskardin, E., Aichernig, B.K., Pill, I., Tappler, M.: Learning finite state models from recurrent neural networks. In: ter Beek, M.H., Monahan, R. (eds.) Integrated Formal Methods - 17th International Conference, IFM 2022, Lugano, Switzerland, June 7-10, 2022, Proceedings. Le...

    2022 doi

  12. [20]

    In: Bunke, H

    Oncina, J., García, P.: Identifying regular languages in polynomial time. In: Bunke, H. (ed.) Advances in Structural and Syntactic Pattern Recognition. Se- ries in Machine Perception and Artificial Intelligence, vol. 5, pp. 99–108. World Scientific (1993).https://doi.org/10.11...

    1993 doi

  13. [21]

    In: International Con- ference on Protocol Specification, Testing and Verification

    Peled, D., Vardi, M.Y., Yannakakis, M.: Black box checking. In: International Con- ference on Protocol Specification, Testing and Verification. pp. 225–240. Springer (1999) 20 Benjamin von Berg (B) and Bernhard K. Aichernig

    1999

  14. [22]

    Lecture Notes in Computer Science, vol

    Pferscher, A., Aichernig, B.K.: Fingerprinting bluetooth low energy devices via activeautomatalearning.In:Huisman,M.,Pasareanu,C.S.,Zhan,N.(eds.)Formal Methods - 24th International Symposium, FM 2021, Virtual Event, November 20- 26, 2021, Proceedings. Lecture Notes in Computer...

    2021 doi

  15. [23]

    In: Deshmukh, J.V., Havelund, K., Perez, I

    Pferscher, A., Aichernig, B.K.: Stateful black-box fuzzing of bluetooth devices us- ing automata learning. In: Deshmukh, J.V., Havelund, K., Perez, I. (eds.) NASA Formal Methods - 14th International Symposium, NFM 2022, Pasadena, CA, USA, May 24-27, 2022, Proceedings. Lecture ...

    2022 doi

  16. [24]

    In: Jansen, N., Tribastone, M

    Reynouard,R.,Ingólfsdóttir,A.,Bacci,G.:Jajapy:Alearninglibraryforstochastic models. In: Jansen, N., Tribastone, M. (eds.) Quantitative Evaluation of Systems - 20th International Conference, QEST 2023, Antwerp, Belgium, September 20- 22, 2023, Proceedings. Lecture Notes in Comp...

    2023 doi

  17. [25]

    ACM Trans

    Shijubo, J., Waga, M., Suenaga, K.: Probabilistic black-box checking via active MDP learning. ACM Trans. Embed. Comput. Syst.22(5s), 148:1–148:26 (2023). https://doi.org/10.1145/3609127

    2023 doi

  18. [26]

    In: Proceedings of the 46th IEEE/ACM International Conference on Software Engineering, ICSE 2024, Lisbon, Portugal, April 14-20, 2024

    Tappler, M., Pferscher, A., Aichernig, B.K., Könighofer, B.: Learning and repair of deep reinforcement learning policies from fuzz-testing data. In: Proceedings of the 46th IEEE/ACM International Conference on Software Engineering, ICSE 2024, Lisbon, Portugal, April 14-20, 202...

    2024

  19. [27]

    In: Margaria, T., Steffen, B

    Tappler, M., Pranger, S., Könighofer, B., Muskardin, E., Bloem, R., Larsen, K.G.: Automata learning meets shielding. In: Margaria, T., Steffen, B. (eds.) Leveraging Applications of Formal Methods, Verification and Validation. Verification Princi- ples - 11th International Symp...

    2022 doi

  20. [28]

    CoRRabs/2203.16331(2022).https://doi

    Verwer, S., Hammerschmidt, C.A.: Flexfringe: Modeling software behavior by learning probabilistic automata. CoRRabs/2203.16331(2022).https://doi. org/10.48550/ARXIV.2203.16331

    2022 doi

  21. [29]

    In: Sempere, J.M., García, P

    Verwer, S., de Weerdt, M., Witteveen, C.: A likelihood-ratio test for identifying probabilistic deterministic real-time automata from positive data. In: Sempere, J.M., García, P. (eds.) Grammatical Inference: Theoretical Results and Applica- tions, 10th International Colloquiu...

    2010 doi

  22. [30]

    Walkinshaw, N., Taylor, R., Derrick, J.: Inferring extended finite state machine models from software executions. Empir. Softw. Eng.21(3), 811–853 (2016). https://doi.org/10.1007/S10664-015-9367-7

    2016 doi

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.