Bisimulation Learning

TL;DR

The paper tackles the challenge of computing finite abstractions for systems with large or infinite state spaces by introducing a data-driven, stutter-insensitive bisimulation method for deterministic transition systems. It reframes partitioning as learning a state classifier and per-class ranking functions within a counterexample-guided inductive synthesis loop powered by an SMT verifier, grounded in well-founded bisimulation theory. The approach yields succinct, interpretable abstractions that preserve $LTL_{\u0301setminus\bigcirc}$ properties and demonstrates faster, more informative verification on reactive verification and software model checking benchmarks compared to state-of-the-art tools. The work lays a foundation for extensions to non-deterministic and continuous-state settings and suggests potential incorporation of neural architectures for scalable state representations while maintaining automatic, diagnostics-friendly abstractions.

Abstract

We introduce a data-driven approach to computing finite bisimulations for state transition systems with very large, possibly infinite state space. Our novel technique computes stutter-insensitive bisimulations of deterministic systems, which we characterize as the problem of learning a state classifier together with a ranking function for each class. Our procedure learns a candidate state classifier and candidate ranking functions from a finite dataset of sample states; then, it checks whether these generalise to the entire state space using satisfiability modulo theory solving. Upon the affirmative answer, the procedure concludes that the classifier constitutes a valid stutter-insensitive bisimulation of the system. Upon a negative answer, the solver produces a counterexample state for which the classifier violates the claim, adds it to the dataset, and repeats learning and checking in a counterexample-guided inductive synthesis loop until a valid bisimulation is found. We demonstrate on a range of benchmarks from reactive verification and software model checking that our method yields faster verification results than alternative state-of-the-art tools in practice. Our method produces succinct abstractions that enable an effective verification of linear temporal logic without next operator, and are interpretable for system diagnostics.

Figures (9)

• Figure 1: Learned stutter-insensitive bisimulation of the Euclidean algorithm.
• Figure 2: Iterative process of bisimulation learning. Starting from the initial label-preserving partition (a), our procedure generates counterexamples (blue dots) until it attains a valid stutter-insensitive bisimulation (c).
• Figure 3: Trajectory-based representation of the stutter-insensitive stability condition.
• Figure 4: A stutter-insensitive but not divergence-sensitive bisimulation $\simeq$ is indicated by the dashed lines. It holds that ${\cal M} \models \lozenge(\text{red})$ but ${\cal M/_{\simeq}} \not \models \lozenge(\text{red})$.
• Figure 5: Intuitive representation of Theorem \ref{['thm:rankstutt']}. Since a state $s \in R$ has a successor in $Q$, the value of $h_R$ must strictly decrease along any trajectory through $R$. Therefore, all states in $R$ eventually transition to $Q$ after possible stuttering.

Theorems & Definitions (22)

• definition thmcounterdefinition: Transition Systems
• definition thmcounterdefinition: Partitions
• definition thmcounterdefinition: Divergence Sensitivity
• definition thmcounterdefinition: Quotient
• definition thmcounterdefinition: Label-preserving Partitions
• definition thmcounterdefinition: Stutter-insensitive Bisimulation
• lemma thmcounterlemma
• proof
• lemma thmcounterlemma
• proof