Learning event-driven switched linear systems

Atreyee Kundu; Pavithra Prabhakar

REVIEW 2 major objections 6 minor 35 references

Learning event-driven switched linear systems

T0 review · 2 major / 6 minor · reviewed 2026-08-27 · deepseek-v4-flash

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

Pith's one-line read Black-box switched systems can be learned exactly in finite time

desk verdict A sound, modest L*-based active learner for switched linear systems whose interesting new trick is recovering subsystem matrices from basis-propagation executions, but the implementation's finite-length equivalence check is not covered by the main theorem. read the letter →

arxiv 2009.12831 v1 pith:BTXVFBCX submitted 2020-09-27 eess.SY cs.LGcs.SY

Atreyee Kundu , Pavithra Prabhakar This is my paper · ORCID

classification eess.SYcs.LGcs.SY MSC 68Q3268Q4593B3093C30

keywords switchedlinearsystemsblack-boxidentificationactivelearningL*algorithmfiniteautomataequivalencequeriessystemcounterexamples

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

This paper claims that an unknown event-driven switched linear system—a finite automaton whose nodes are labeled by subsystem matrices—can be learned exactly from black-box access. The learner needs only the event set and the matrix dimension, plus two oracles: an input–output generator that simulates the system, and an equivalence checker that, given a hypothesis automaton, either confirms language equality or returns a counterexample word. The proposed algorithm first recovers the label of the last matrix on any input word by solving linear equations from executions on basis vectors, then applies an extension of the classic L* algorithm to learn the automaton's language. If the claim is correct, the algorithm terminates in bounded time and outputs an automaton whose executions match the unknown system for every initial continuous state and every input word.

What carries the argument

The load-bearing object is the output function $\mathrm{Output}_D(w)$, the matrix label of the last node reached by the run on $w$; it plays the role that acceptance plays in ordinary DFA learning. Algorithm 1 computes it with a constant number of IO-generator queries: run the system on the word from the $d\times d$ identity matrix, take the last two frames $X$ and $X'$, and solve $X' = A X$; full rank makes $A$ unique. The second ingredient is the multi-label extension of L*: a pair $(Q,T)$ of access and test words is $D$-separable when every pair of access words is distinguished by some test word, and $D$-closed when every one-step extension is represented in $Q$. A closed and separable pair directly yields a hypothesis automaton, and the equivalence oracle either certifies it or supplies a counterexample whose prefix binary search expands the accessible state set.

What would settle it

Take the target automaton from Example 6 and supply an equivalence checker that tests only words up to length $L=3$; run Algorithm 2. If it outputs an automaton whose language equals the target on all words of length at most 3 but differs on some longer word, the approximate checker has failed to certify exactness. More directly, construct two finite automata with identical output functions on all words up to length $L$ but differing beyond $L$; a checker that stops at $L$ cannot return the distinguishing word, so the algorithm would accept the wrong automaton.

Watch

Extended reading notes

Core claim

The central discovery is a reduction of switched-system identification to finite-automaton language learning, with the dynamics separated from the switching logic. Algorithm 1 computes $\mathrm{Output}_D(w)$, the matrix labeling the final node of the run on $w$, by executing the system from the identity basis and solving $X' = A X$ for $A$; this needs full-rank subsystem matrices. With this output function, the problem becomes learning an event-deterministic automaton with multiple node labels. Algorithm 2 maintains a $D$-separable, $D$-closed pair $(Q,T)$ of access and test words, builds a hypothesis automaton from $Q$, and uses an equivalence query; a returned counterexample $w$ is processed by a binary search over prefixes to find a new access word, strictly expanding $Q$ while preserving separability. Since $|Q|$ is bounded by the number of states of a minimal automaton for the unknown language, the loop terminates, and Theorem 1 states that the final hypothesis automaton has language $L_D$; Corollary 1 concludes that $\mathrm{Exec}_D(x,w) = \mathrm{Exec}_{D'}(x,w)$ for every $x \in \mathbb{R}^d$ and $w \in \Sigma^*$.

Load-bearing premise

The proof of finite-time exactness rests on an equivalence oracle that can always decide language equivalence and, when the hypothesis is wrong, return an input word on which the two outputs differ; if that oracle is only approximate or restricted to words of bounded length, the algorithm's termination and exactness guarantees no longer follow.

Editorial extensions

If this is right

Exact behavioral identification: once Algorithm 2 returns $D'$, the learned switched system reproduces every execution of the original system from any initial continuous state and any event sequence (Corollary 1).
Finite termination: each counterexample strictly grows the set of access words while separability caps $|Q|$ at the number of states of a minimal automaton for $L_D$, so the algorithm is guaranteed to halt.
Oracle-driven identification: the method applies to any black-box system for which an IO-generator and an equivalence checker with counterexamples are available; no prior knowledge of the transition structure or the subsystem matrices is needed beyond dimension $d$ and event set $\Sigma$.
Generality: the same framework learns any deterministic finite automaton with zero accepting nodes whose nodes carry full-rank matrix labels, covering switched linear systems as the motivating case.
Practical scalability: the offline experiments show the algorithm learns automata with thousands of states, with runtime dominated by the number of IO-generator queries.

Reading between the lines

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

Beyond the paper: if the equivalence oracle is replaced by finite-length search, as in the implementation, the exactness guarantee weakens; an automaton that agrees with the target on all words up to length $L$ can still differ on a longer word, so the learned model is certified only up to $L$.
Beyond the paper: exact recovery of matrix labels via Algorithm 1 depends on noise-free observations and full-rank subsystems; a noisy setting would require a statistical estimator for the last-node matrix, which the paper does not address.
Beyond the paper: because the state bound is the minimal automaton size, the query complexity is essentially optimal in the number of states, but per-query cost grows with $d$ and word length, making high-dimensional systems a likely practical bottleneck.
Beyond the paper: a natural testable extension relaxes full rank; if a subsystem matrix is rank-deficient, the identity-basis construction recovers only part of the matrix, suggesting quotient-based learning of the switching logic without the full linear dynamics.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Request a human review

A listed scientist reviews the paper for a fee and the review publishes here regardless of verdict. See the reviewers or get listed.

Editorial analysis

A structured set of objections, weighed in public.

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

Desk Editor's Note

read the letter

Quick take: this is a sound, modest active-learning paper. The genuinely new piece is Algorithm 1, which recovers the matrix labeling the current mode from black-box executions by applying the unknown subsystem matrices to the identity basis; because the matrices are assumed full-rank, two executions determine the matrix exactly. That reduction is correct and is what separates the paper from a routine L* exercise. The L* extension to Moore machines with matrix outputs follows Angluin faithfully, and Lemma 5's binary search for a distinguishing suffix is standard but properly adapted. The separation of dynamics identification from automaton learning is a useful framing, and the experiments on automata with up to 2000 states show the implementation actually runs.

The soft spot is the gap between the theorem and the implementation. Theorem 1 and Corollary 1 rely on an exact equivalence oracle: it must decide LD = LD' and, when unequal, return a word w with OutputD(w) different from OutputD'(w). The MATLAB counterexample generator in Section 5 only enumerates words up to a chosen length L and accepts the hypothesis when no mismatch is found. No bound is given on the length of the shortest distinguishing word, so two automata can agree on all words up to L and differ later. The implementation can therefore output a wrong automaton, and the correctness claim for the experiments does not follow from Theorem 1. Remark 4 essentially concedes this by saying 'up to a sufficiently large number,' but Example 5 and the experiments still treat absence of a counterexample as success. There is a standard repair: if an upper bound on the target number of states were known, enumerating words up to the product bound would make the oracle exact; the paper does not do this.

Two smaller issues. Algorithm 1's epsilon branch returns ExecD(Id, epsilon) rather than the last matrix of that execution; it should return Last(...). Easy fix. And the proof of Theorem 1 is compressed to a paragraph; the real work is in Lemmas 2 through 5, which are fine.

The citation pattern looks appropriate: it cites the switched-identification literature and the automata-learning literature, and it is explicit about [3] being related label-query work. There is no fitting-to-data or self-citation problem.

Verdict: send to review. The theoretical result is correct under its stated oracle, and the main gap is fixable and clearly located. A referee should ask for the epsilon fix, an explicit statement that Theorem 1 assumes an exact oracle, and either a heuristic label for Section 5 or conditions under which finite enumeration is exact. This paper is for researchers in automata learning and formal verification of cyber-physical systems; for them it is a useful, if not groundbreaking, bridging result.

Referee Report

2 major / 6 minor

Summary. The paper addresses the identification of event-driven switched linear systems modeled as deterministic finite automata whose nodes are labeled with subsystem matrices. Assuming known event set and matrix dimension, and access to an IO-generator oracle that simulates executions and an equivalence-checker oracle that returns counterexamples, the authors first show how to recover the label of the last node reached by a word from a constant number of execution queries (Algorithm 1), and then adapt Angluin's L* algorithm to learn the underlying automaton with multiple labels (Algorithm 2). The main theoretical result, Theorem 1, states that Algorithm 2 always terminates and outputs an automaton with the same language as the unknown system, and Corollary 1 extends this to equality of all executions. The paper also reports numerical experiments on examples up to 2000 states.

Significance. The paper makes a clean conceptual contribution by separating the dynamics-identification step from the automaton-learning step, and by extending the classical L* algorithm to deterministic automata with matrix-valued node labels and no accepting states. The proofs of the key lemmas are standard L* arguments and are, apart from the epsilon-case bug discussed below, sound. The theoretical result is conditional on an exact equivalence oracle, which is a strong assumption; the practical implementation in Section 5 only approximates this oracle by finite enumeration, so the experimental claims do not currently carry the finite-time correctness guarantee. With these gaps addressed, the paper would be of interest to the hybrid systems and active automata learning communities.

major comments (2)

[§4.1, Algorithm 1, Lemma 1] For w = epsilon, Algorithm 1 (lines 1-2) outputs the full execution ExecD(Id, epsilon), which by Definition 6 is the sequence (Id, A0) with A0 = gamma(q0), rather than the matrix OutputD(epsilon) = A0. Lemma 1 therefore does not hold as stated, and the initial node label needed in Definition 10 cannot be obtained from the printed algorithm. This is easily repaired by outputting Last(ExecD(Id, epsilon)) (or equivalently GetMatrix(Id, Last(ExecD(Id, epsilon)))), but the pseudocode and the lemma statement should be corrected.
[§5, Remark 4, Theorem 1] The implementation of the equivalence checker in fa-learn.m (Remark 4 and Section 5) enumerates all words up to a pre-chosen length L and declares the hypothesis correct when no mismatch is found. This does not implement the exact equivalence oracle of Problem 1(b), and no bound on L is given in terms of the unknown automaton. Two automata can agree on all words up to length L while differing on a longer word, so the implemented algorithm can terminate with a hypothesis D' such that LD differs from LD'. Consequently, the experimental results do not inherit the guarantee of Theorem 1. The paper should either provide a completeness bound for counterexample generation (e.g., via a state-count bound as in conformance testing) or explicitly state that the finite-length check is a heuristic without the finite-time correctness claim.

minor comments (6)

[§4.2, Lemma 2 and Lemma 4 proofs] The proof of Lemma 2 contains the phrase 'with at most with ND states' (duplicated 'with'), and the proof of Lemma 4 refers to 'Lemma' without a number; it should refer to Lemma 3.
[Remark 2] The phrase 'D has 0-many accepting nodes' is confusing; it should read 'D has no accepting nodes'.
[§5] The hardware description 'Intel 17-8550U' should be 'Intel i7-8550U'.
[Table 1] The table header 'Execution time of Algorithm 1' is misleading because the column reports the total time of the learning procedure, not merely the time of Algorithm 1.
[Example 7, footnote 1] The footnote states that the benchmark examples are for Moore machines; the paper should clarify that these are random automata with user-chosen parameters rather than established switched-system benchmarks.
[Algorithm 1, line 4] For n=1, the notation w[1...n-1] denotes w[1...0], which is not previously defined; it should be stated that w[1...0] is epsilon.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the identification argument is a standard L* extension driven by external oracles, with no fitted quantity renamed as a prediction and no load-bearing self-citation.

full rationale

The derivation chain is self-contained relative to the two stated oracles. Algorithm 1 computes Output_D(w) from IO-generator executions by solving the linear system AX=X' for full-rank matrices; this is direct recovery of a label from queried traces, not a parameter fitted to data and then reused as a prediction. Algorithm 2 is a faithful extension of Angluin's L*: correctness is the standard "halt only after the equivalence oracle certifies LD=LD'" condition, and termination follows from Lemma 2's |Q| <= N_D bound together with Lemma 5's constructive counterexample expansion, which uses only Output queries and binary search. The cited foundations (Angluin's L*, Worrell's presentation) are external standard results, and the authors' own earlier work is not used to justify any load-bearing premise. The practical caveats noted in the paper are correctness/assumption limitations rather than circularity: Algorithm 1's epsilon branch returns Exec_D(I_d, epsilon)=I_d instead of the initial label matrix, and the finite-length enumeration in Remark 4 and Section 5 does not implement the exact Problem 1(b) equivalence oracle, so Theorem 1's universal guarantee does not transfer to the implemented routine. Neither limitation makes the derivation equivalent to its inputs.

Assumptions & free parameters 1 free parameters · 5 assumptions · 0 invented entities

The algorithm inherits the full-rank and oracle assumptions stated in Section 3.3; no free parameters are fitted in the proof, and no new physical entities are introduced. The practical counterexample search bound L is an implementation parameter.

free parameters (1)

L: maximum length of words enumerated by the practical counterexample generator = not reported
Remark 4 chooses a large number L to emulate equivalence queries; the correctness theorem does not depend on L, and no value is given, which affects reproducibility and the strength of experimental validation.

assumptions (5)

domain assumption Target system is an event-deterministic labelled finite automaton with full-rank subsystem matrices
Sections 3.2 and 3.3; full-rank is needed so GetMatrix solves AX=X' uniquely and basis columns remain bases under all matrix products.
domain assumption IO-generator returns exact, noise-free executions ExecD(x,w) for any input
Problem 1(a); exactness is not stated as an approximation, and noise is left to future work in the conclusion.
domain assumption Equivalence checker exists and is exact for language equivalence
Problem 1(b); the guarantees of Theorem 1 depend on it, while Remark 4 shows experiments use finite enumeration instead.
standard math Standard Angluin L* correctness
Algorithm 2 and Lemmas 2 to 5 use the standard L* framework from [2,35]; it is not re-proved from first principles.
domain assumption Unknown automaton is deterministic and complete
Definition 1 and the construction of D' require a transition for every state and event pair, and determinism is used in Lemma 5.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Learning event-driven switched linear systems." pith.science (2026). https://pith.science/paper/BTXVFBCX

@misc{pith2026200912831,
  author       = {Pith},
  title        = {Pith review of: Learning event-driven switched linear systems},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/BTXVFBCX}},
  note         = {Machine review of arXiv:2009.12831}
}

abstract

We propose an automata theoretic learning algorithm for the identification of black-box switched linear systems whose switching logics are event-driven. A switched system is expressed by a deterministic finite automaton (FA) whose node labels are the subsystem matrices. With information about the dimensions of the matrices and the set of events, and with access to two oracles, that can simulate the system on a given input, and provide counter-examples when given an incorrect hypothesis automaton, we provide an algorithm that outputs the unknown FA. Our algorithm first uses the oracle to obtain the node labels of the system run on a given input sequence of events, and then extends Angluin's $L^*$-algorithm to determine the FA that accepts the language of the given FA. We demonstrate the performance of our learning algorithm on a set of benchmark examples.

Figures

Figures reproduced from arXiv: 2009.12831 by the authors.

**Figure 1.** FA for Example 1 Note that the transition function of our automaton is deterministic. We will refer to a sequence of event, that is, an element of Σ∗ , as an input (word or sequence). We overload δ to also denote the function δ ∶ Q × Σ ∗ → Q that given a state and an input word and outputs the state reached on taking the sequence of transitions corresponding to the input word, and is inductively defined as δ(q, ε) =… view at source ↗

**Figure 2.** Hypothesis FA D ′ in Step 4. of Example 5 A1 A2 A3 A2 e1 e1 e1 e1 e2 e2 e2 e2 [PITH_FULL_IMAGE:figures/full_fig_p011_2.png] view at source ↗

**Figure 3.** Hypothesis FA D ′ in Step 5. of Example 5 To wrap up, let us discuss the problem of learning the switched system. Given a switched system D with d and Σ known, Algorithm 2 outputs a switched system D ′ whose executions coincide with that of D. Corollary 1. Algorithm 2 outputs a switched system D ′ such that ExecD(x, w) = ExecD′(x, w) for every x ∈ R d and w ∈ Σ ∗ . Proof. This follows immediate from Theorem 1, where… view at source ↗

Figures from the paper (2 more)

**Figure 4.** Figure 4: FA for Example 6 A1 A2 fault fault, ideal ideal [PITH_FULL_IMAGE:figures/full_fig_p013_4.png]

**Figure 6.** Figure 6: Hypothesis automaton D ′ in Step 5. of Example 6 Example 7. We choose two benchmark examples described in [27, §4.4].1 The following procedure is executed in each case: 1) Construction of a switched system: A) We specify the number of nodes, ∣Q∣, the number of events, …

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

35 extracted references · 35 canonical work pages

[3]

Angluin, B

D. Angluin, B. Becerra-Bonache, A. H. Dediu, and L. Reyzin , Learning ﬁnite automata using label queries , Proceedings of the 20th International Conference on Algor ithmic Learning Theory, (2009), pp. 171–185

work page 2009
[1]

Aarts and F

F. Aarts and F. V aandrager , Learning i/o automata , in CONCUR 2010 - Concurrency Theory, P. Gastin and F. Laroussinie, eds., Berlin, Heidelberg, 201 0, Springer Berlin Heidelberg, pp. 71–85

work page 2010
[2]

Angluin , Learning regular sets from queries and counterexamples , Inform

D. Angluin , Learning regular sets from queries and counterexamples , Inform. and Comput., 75 (1987), pp. 87–106. 1The benchmark examples under consideration are for Moore Ma chines, and does not involve matri- ces. We, therefore, choose the dimension of the subsystems m atrices to cater to our purpose. 15

work page 1987
[4]

Bako , Identiﬁcation of switched linear systems via sparse optimi zation, Automatica J

L. Bako , Identiﬁcation of switched linear systems via sparse optimi zation, Automatica J. IF AC, 47 (2011), pp. 668–677

work page 2011
[5]

L. Bako, K. Boukharouba, E. Duviella, and S. Lecoeuche , A recursive identiﬁcation algorithm for switched linear/aﬃne models , Nonlinear Anal. Hybrid Syst., 5 (2011), pp. 242–253

work page 2011
[6]

E. T. Barr, M. Harman, P. McMinn, M. Shahbaz, and S. Yoo , The oracle problem in software testing: A survey , IEEE Transactions on Software Engineering, 41 (2015), pp. 507–525

work page 2015
[7]

Bemporad, A

A. Bemporad, A. Garulli, S. Paoletti, and A. Vicino , A bounded-error approach to piecewise aﬃne system identiﬁcation , IEEE Trans. Automat. Control, 50 (2005), pp. 1567–1580

work page 2005
[8]

A. B.K., M. W., M. M.R., T. M., and T. M. , Model learning and model-based testing , Bennaceur A., HÃďhnle R., Meinke K. (eds) Machine Learning for Dynamic Software Analysis: Potentials and Limits. Lecture Notes in Computer Science, 11026 (2018)

work page 2018

Show all 35 references

[9]

Bollig, P

B. Bollig, P. Habermehl, C. Kern, and M. Leucker , Angluin-style learning of nfa , International Joint Conference on Artiﬁcial Intelligence, (2009), pp. 10 04–1009

2009
[10]

Cassel, F

S. Cassel, F. Howar, and B. e. a. Jonsson , Active learning for extended ﬁnite state machines , Formal Aspects of Computing, 28 (2016), pp. 233–263

2016
[11]

Clarke, O

E. Clarke, O. Grumberg, and D. Peled , Model checking , Cambridge:MIT Press, 1999

1999
[12]

J. M. Cobleigh, D. Giannakopoulou, and C. S. P ˘As ˘Areanu, Learning assumptions for composi- tional veriﬁcation , in Tools and Algorithms for the Construction and Analysis o f Systems, H. Gar- avel and J. Hatcliﬀ, eds., Berlin, Heidelberg, 2003, Spring er Berlin Heidelberg, p...

2003
[13]

M. D. Comparetti, E. Beretta, M. Kunze, E. D. Momi, J. Raczkowsk y, and G. Ferrigno , Event- based device-behavior switching in surgical human-robot i nteraction, IEEE International Confer- ence on Robotics and Automation (ICRA), (2014), pp. 1877–18 82

2014
[14]

Z. Du, L. Balzano, and N. Ozay , A robust algorithm for online switched system identiﬁcatio n, IF AC Symposium on System Identiﬁcation (SYSID), (2018), pp . 293–298

2018
[15]

Ferrari-Trecate, M

G. Ferrari-Trecate, M. Muselli, D. Liberati, and M. Morari , A clustering technique for the identiﬁcation of piecewise aﬃne systems , Automatica J. IF AC, 39 (2003), pp. 205–217

2003
[16]

Garulli, S

A. Garulli, S. Paoletti, and A. Vicino , A survey on switched and piecewise aﬃne system iden- tiﬁcation , IF AC Symposium on System Identiﬁcation, (2012), pp. 344–3 55

2012
[17]

Giannakopoulou and C

D. Giannakopoulou and C. S. Pasareanu , Abstraction and learning for inﬁnite-state composi- tional veriﬁcation , in Festschrift for Dave Schmidt, 2013

2013
[18]

Goudjil, M

A. Goudjil, M. Pouliquen, E. Pigeon, and O. Gehan , Convergence analysis of a real-time identi- ﬁcation algorithm for switched linear systems with bounded noise, IEEE Conference on Decision and Control (CDC), (2016), pp. 2957–2962

2016
[19]

Grinchtein, M

O. Grinchtein, M. Leucker, and N. Piterman , Inferring network invariants automatically , Pro- ceedings of the 3rd International Joint Conference on Autom ated Reasoning (IJCARâĂŹ06), volume 4130 of Lecture Notes in Artiﬁcial Itelligence, (2006)

2006
[20]

R. Groz, N. Bremond, A. Simao, and C. Oriat , hw-inference: A heuristic approach to retrieve models through black box testing , Journal of Systems and Software, (2020), p. 110426

2020
[21]

Howar, B

F. Howar, B. Steffen, B. Jonsson, and S. Cassel , Inferring canonical register automata , in Veriﬁ- cation, Model Checking, and Abstract Interpretation, V. Ku ncak and A. Rybalchenko, eds., Berlin, Heidelberg, 2012, Springer Berlin Heidelberg, pp. 251–266

2012
[22]

A. L. Juloski, S. Weiland, and W. P. M. H. Heemels , A Bayesian approach to identiﬁcation of hybrid systems , IEEE Trans. Automat. Control, 50 (2005), pp. 1520–1533

2005
[23]

Kumar, P

V. Kumar, P. Madhusudan, and M. Viswanathan , Minimization, learning, and conformance test- ing of boolean programs , Baier C., Hermanns H. (eds) CONCUR 2006 âĂŞ Concurrency The ory. CONCUR 2006. Lecture Notes in Computer Science, vol 4137. Sp ringer, Berlin, Heidelberg, (2006...

2006
[24]

Lauer, On the complexity of switching linear regression , Automatica J

F. Lauer, On the complexity of switching linear regression , Automatica J. IF AC, 74 (2016), pp. 80– 83

2016
[25]

Liberzon , Switching in Systems and Control , Systems & Control: Foundations & Applications, Birkh¨ auser Boston Inc., Boston, MA, 2003

D. Liberzon , Switching in Systems and Control , Systems & Control: Foundations & Applications, Birkh¨ auser Boston Inc., Boston, MA, 2003

2003
[26]

Moerman , Learning product automata , Proceedings of Machine Learning Research, 93 (2019), pp

J. Moerman , Learning product automata , Proceedings of Machine Learning Research, 93 (2019), pp. 54–66

2019
[27]

Neider, R

D. Neider, R. Smetsers, F. V aandrager, and H. Kuppens , Benchmarks for automata learning and conformance testing , Models, Mindsets, Meta: The What, the How, and the Why Not?, (2019), pp. 390–416

2019
[28]

N. Ozay, C. Lagoa, and M. Sznaier , Set membership identiﬁcation of switched linear systems wi th known number of subsystems , Automatica J. IF AC, 51 (2015), pp. 180–191

2015
[29]

Paoletti, A

S. Paoletti, A. L. Juloski, G. Ferrari-Trecate, and R. Vidal , Identiﬁcation of hybrid systems: A tutorial , European Journal of Control, 13 (2007), pp. 242–260

2007
[30]

C. H. Papadimitriou and K. Steiglitz , Combinatorial optimization: algorithms and complexity , Dover Publications Inc., Mineola, NY, 1998. Corrected repr int of the 1982 original

1998
[31]

J. Roll, A. Bemporad, and L. Ljung , Identiﬁcation of piecewise aﬃne systems via mixed-integer programming, Automatica J. IF AC, 40 (2004), pp. 37–50

2004
[32]

Tzeng , Learning probabilistic automata and markov chains via quer ies, Machine Learning, 8 (1992), pp

W. Tzeng , Learning probabilistic automata and markov chains via quer ies, Machine Learning, 8 (1992), pp. 151–166

1992
[33]

Vidal , Recursive identiﬁcation of switched ARX systems , Automatica J

R. Vidal , Recursive identiﬁcation of switched ARX systems , Automatica J. IF AC, 44 (2008), pp. 2274–2287

2008
[34]

Vidal, S

R. Vidal, S. Soatto, Y. Ma, and S. Sastry , An algebraic geometric approach to the identiﬁcation of a class of linear hybrid systems , IEEE Conference on Decision and Control, (2003), pp. 167–1 72

2003
[35]

Worrell, Exactly learning regular languages using membership and eq uivalence queries , 2017

J. Worrell, Exactly learning regular languages using membership and eq uivalence queries , 2017. A vailable at https://www.cs.ox.ac.uk/people/james.worrell/DF A-learning.pdf

2017

Pith tools

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

[1] [3]

Angluin, B

D. Angluin, B. Becerra-Bonache, A. H. Dediu, and L. Reyzin , Learning ﬁnite automata using label queries , Proceedings of the 20th International Conference on Algor ithmic Learning Theory, (2009), pp. 171–185

work page 2009

[2] [1]

Aarts and F

F. Aarts and F. V aandrager , Learning i/o automata , in CONCUR 2010 - Concurrency Theory, P. Gastin and F. Laroussinie, eds., Berlin, Heidelberg, 201 0, Springer Berlin Heidelberg, pp. 71–85

work page 2010

[3] [2]

Angluin , Learning regular sets from queries and counterexamples , Inform

D. Angluin , Learning regular sets from queries and counterexamples , Inform. and Comput., 75 (1987), pp. 87–106. 1The benchmark examples under consideration are for Moore Ma chines, and does not involve matri- ces. We, therefore, choose the dimension of the subsystems m atrices to cater to our purpose. 15

work page 1987

[4] [4]

Bako , Identiﬁcation of switched linear systems via sparse optimi zation, Automatica J

L. Bako , Identiﬁcation of switched linear systems via sparse optimi zation, Automatica J. IF AC, 47 (2011), pp. 668–677

work page 2011

[5] [5]

L. Bako, K. Boukharouba, E. Duviella, and S. Lecoeuche , A recursive identiﬁcation algorithm for switched linear/aﬃne models , Nonlinear Anal. Hybrid Syst., 5 (2011), pp. 242–253

work page 2011

[6] [6]

E. T. Barr, M. Harman, P. McMinn, M. Shahbaz, and S. Yoo , The oracle problem in software testing: A survey , IEEE Transactions on Software Engineering, 41 (2015), pp. 507–525

work page 2015

[7] [7]

Bemporad, A

A. Bemporad, A. Garulli, S. Paoletti, and A. Vicino , A bounded-error approach to piecewise aﬃne system identiﬁcation , IEEE Trans. Automat. Control, 50 (2005), pp. 1567–1580

work page 2005

[8] [8]

A. B.K., M. W., M. M.R., T. M., and T. M. , Model learning and model-based testing , Bennaceur A., HÃďhnle R., Meinke K. (eds) Machine Learning for Dynamic Software Analysis: Potentials and Limits. Lecture Notes in Computer Science, 11026 (2018)

work page 2018