Bisimulation: Definition, Types, and Applications

• Bisimulation is a coinductive relation that matches observations and transitions in both directions, defining behavioral equivalence as the greatest fixed point of a system’s transition operator.
• Strong, weak, branching, probabilistic, fuzzy, quantum, and approximate variants adapt the matching criteria to internal actions, uncertainty, continuous dynamics, and implementation details.
• Researchers use bisimulation for model checking, process verification, system minimization, neural-network reduction, and abstraction, with finite-state algorithms such as Paige–Tarjan running in O(m log n) time.

Bisimulation is a coinductive relation for comparing the observable and transition behavior of states, processes, automata, dynamical systems, probabilistic models, and other state-based structures. Related states must match one another’s behavior, usually in both directions, while preserving observations and recursively relating corresponding successors. In its classical form, a relation $R$ on a labelled transition system is a bisimulation when $uRv$ implies that every transition $u\xrightarrow{a}u'$ can be matched by $v\xrightarrow{a}v'$ with $u'Rv'$, and conversely. Bisimilarity is the greatest bisimulation, equivalently the greatest fixed point of the associated behavioral operator. The notion has been generalized to weak and branching process equivalences, probabilistic and fuzzy systems, quantum processes, differential-algebraic systems, weighted automata, neural networks, continuous-time stochastic processes, potentialist systems, and higher-order programs.

1. Fundamental concepts and fixed-point semantics

A labelled transition system consists of states, action labels, and labelled transitions. Strong bisimulation requires a symmetric back-and-forth condition:

$$uRv\land u\xrightarrow{a}u' \Longrightarrow \exists v'.\;v\xrightarrow{a}v'\land u'Rv',$$

together with the converse condition for transitions from $v$. Observations, termination predicates, final-state information, or other state labels must also agree when they are part of the system semantics.

Bisimulation is coinductive. If $\Phi$ is the behavioral operator that maps a relation to the pairs satisfying the matching conditions relative to that relation, then:

$$R\text{ is a bisimulation}\Longleftrightarrow R\subseteq\Phi(R),$$

and bisimilarity is the greatest fixed point:

$\sim=\nu R.\,\Phi(R).$

For finite transition systems, approximants can be defined by initially relating every pair of states and repeatedly removing pairs that fail the forth or back condition. The descending sequence stabilizes after finitely many rounds. Standard partition-refinement algorithms compute bisimulation in polynomial time; the Paige–Tarjan algorithm runs in $uRv$0 time for $uRv$1 vertices and $uRv$2 edges. On unrestricted finite graphs, both bisimulation and simulation are P-complete, with P-hardness already holding for directed acyclic graphs (Ganardi et al., 2018).

Bisimulation is generally stronger than trace, language, or input-output equivalence. Language equivalence records which words can be accepted, or the maximum possibility of executing a word, but can erase the branching structure that produces that behavior. In fuzzy transition systems, two systems may induce the same fuzzy language while differing in how their nondeterministic branches are organized; bisimulation distinguishes them by matching complete transitions and related successor regions (Cao et al., 2010). Likewise, for nondeterministic automata, language equality does not imply structural equivalence under forward, backward-forward, or weak forward bisimulation (Ćirić et al., 2011).

Simulation is the one-sided counterpart of bisimulation. A simulation requires only that every move of the first state be matched by the second. Mutual simulation does not in general coincide with bisimulation, because the two simulation witnesses need not form one relation satisfying the joint back-and-forth invariant (Ganardi et al., 2018).

2. Strong, weak, and branching variants

Strong bisimulation observes every transition, including internal $uRv$3-transitions. Weak bisimulation abstracts from finite sequences of silent transitions. A visible transition may be matched by a path of the form:

$uRv$4

and a silent transition may be matched by zero or more silent transitions. Algebraically, weak bisimulation can be obtained by saturating transitions with $uRv$5-closure or by laxifying the transition system. Strong bisimulation on the saturated system is equivalent to weak bisimulation on the original system (Hermida et al., 2020).

Branching bisimulation is more discriminating than weak bisimulation. It permits silent movement but requires the intermediate state before a visible action to remain related to the original state. This preserves branching structure that ordinary weak bisimulation can discard. The standard inclusion is:

$uRv$6

Semi-branching bisimulation modifies the silent-transition condition and is related to branching bisimulation through apartness-theoretic arguments. In process calculi, weak bisimulation is often not a congruence for nondeterministic choice, while a refined congruent equivalence may be introduced to recover contextual substitutability. For qCCS, strong bisimilarity is a congruence for prefixes, choice, parallel composition, restriction, relabelling, and conditionals; weak bisimilarity is preserved by all qCCS constructors except choice, while a related congruent equivalence is defined to address that failure (Feng et al., 2010).

Open pNets illustrate the symbolic form of these distinctions. Their strong FH-bisimulation compares open transition schemas containing hole actions, predicates, assignments, and global actions. Weak FH-bisimulation permits internal $uRv$7-moves and compares visible hole-action sequences rather than individual silent actions. Strong compositionality holds for suitable hole substitutions; weak compositionality additionally requires that the surrounding pNet cannot observe silent actions (Ameur-Boulifa et al., 2020).

A related distinction appears in stutter-insensitive bisimulation. For deterministic transition systems, a transition leaving an equivalence class may be matched by a finite path that remains within the class for some steps before reaching the corresponding successor class. Ranking functions ensure that these intra-class stuttering segments cannot continue indefinitely. The resulting quotient preserves divergence-sensitive LTL without the next operator, but not the exact one-step temporal granularity required by the next operator (Abate et al., 2024).

3. Algebraic, logical, and categorical formulations

For a relation $uRv$8 between state spaces, logical relations lift $uRv$9 to structured objects such as functions, sets, and measures. For powersets, the relevant lifting is the Egli–Milner relation:

$u\xrightarrow{a}u'$0

A transition system is then a structured operation, and bisimulation is exactly the assertion that the corresponding operations are related by the lifted relation. Strong, weak, branching, and semi-branching bisimulations can be obtained by choosing different derived algebraic structures: one-step transitions for strong bisimulation, saturated transitions for weak bisimulation, and pair-valued transitions retaining intermediate states for branching bisimulation (Hermida et al., 2020).

Coalgebraically, an $u\xrightarrow{a}u'$1-coalgebra is a map $u\xrightarrow{a}u'$2. Relation lifting produces $u\xrightarrow{a}u'$3, and a relation is a bisimulation when:

$u\xrightarrow{a}u'$4

If a final coalgebra exists, every coalgebra has a unique homomorphism into it. Bisimilar states have equal final semantics, and under suitable finality assumptions equality in the final coalgebra characterizes bisimilarity.

Apartness is the inductive dual of bisimulation. If $u\xrightarrow{a}u'$5 denotes the complement of a relation, then:

$u\xrightarrow{a}u'$6

Bisimilarity is a greatest fixed point, whereas apartness is a least fixed point in the ordinary inclusion order. Consequently, bisimilarity is established coinductively by exhibiting a potentially infinite invariant relation, while apartness is established inductively by a finite derivation showing a positive distinction. For weak and branching transition systems, the corresponding weak and branching apartness relations satisfy:

$u\xrightarrow{a}u'$7

The categorical relation between path equality and bisimulation is particularly direct for guarded recursive types. In Ticked Cubical Type Theory, guarded coalgebras have a final guarded coalgebra $u\xrightarrow{a}u'$8, and the paper proves:

$u\xrightarrow{a}u'$9

For guarded labelled transition systems based on finite powersets, ordinary process bisimilarity is therefore equivalent, in the homotopy type-theoretic sense, to path equality. This permits equational reasoning about guarded processes in place of separate coinductive bisimulation proofs (Møgelberg et al., 2018).

4. Probabilistic, fuzzy, and quantum bisimulation

Probabilistic bisimulation extends matching from successor states to probability distributions. In probabilistic labelled systems, distributions may be lifted using weight functions: corresponding probability mass must be coupled through related configurations. This is required when measurement or probabilistic choice produces distributions rather than single successors.

A distribution-based approach treats probability distributions themselves as semantic states. In nondeterministic labelled Markov processes, a transition transforms one distribution into another, while retaining the mass of states capable of performing a measurable set of labels. The resulting bisimulation applies to discrete and uncountable state and action spaces, and can identify systems whose hidden memory differs but whose distribution-level behavior agrees. It identifies, for example, memoryless and memory-full continuous-time constructions when residual exponential delays are behaviorally equivalent to freshly sampled exponential delays. The relation is not generally a congruence for unrestricted parallel composition under centralized schedulers (Hermanns et al., 2014).

Fuzzy transition systems replace probability distributions with fuzzy successor sets. A fuzzy transition system has a transition function:

$v\xrightarrow{a}v'$0

where $v\xrightarrow{a}v'$1 is a possibility or membership degree. Unlike probabilities, outgoing fuzzy values need not sum to $v\xrightarrow{a}v'$2. Bisimulation requires a whole fuzzy transition to be matched by another transition with equal suprema on corresponding $v\xrightarrow{a}v'$3-correlational subsets. For infinite systems, an equivalent largest-bisimulation characterization uses $v\xrightarrow{a}v'$4-matching: a transition of degree $v\xrightarrow{a}v'$5 need only be matched by degrees arbitrarily close to $v\xrightarrow{a}v'$6. On image-finite systems, ordinary and strong fuzzy bisimulation coincide. Quotients and homomorphisms can reduce infinite fuzzy systems to finite behavioral representations (Cao et al., 2010).

Quantum-process bisimulation must compare process syntax together with density operators, owned quantum variables, reduced states, probabilistic measurement branches, and arbitrary environmental quantum operations. In qCCS, configurations have the form $v\xrightarrow{a}v'$7, and transitions produce finite-support probability distributions over configurations. A quantum-input clause quantifies over all trace-preserving super-operators acting on the external environment, thereby accounting for incoming systems entangled with systems outside the process scope. Strong and weak bisimilarity are congruences for the principal qCCS combinators and support verification of protocols such as teleportation, superdense coding, and quantum circuits (Feng et al., 2010).

Symbolic quantum bisimulation replaces concrete density operators with snapshots containing quantum operations. Symbolic transitions are weighted by completely positive super-operators and guarded by Boolean conditions for classical data. This avoids enumerating the continuum of quantum states. Symbolic bisimulation is equivalent, under strong semantics, to open bisimulation, while symbolic ground bisimulation omits closure under arbitrary external super-operator application and can be checked algorithmically for finitary systems, especially processes free of quantum input (Feng et al., 2012).

5. Continuous, algebraic, and quantitative systems

For linear differential-algebraic systems,

$v\xrightarrow{a}v'$8

bisimulation is a subspace $v\xrightarrow{a}v'$9 whose related states have equal outputs and whose possible trajectories can be matched in both directions under common external inputs. Singular $u'Rv'$0 matrices make consistency constraints essential: not every state is an admissible initial state. The maximal bisimulation relation can be computed through descending finite-dimensional subspace iteration using kernels, images, controlled invariants, disturbance freedoms, and rank tests. For regular pencils $u'Rv'$1, the disturbance-related freedom condition disappears, and bisimulation implies equality of transfer matrices, although transfer equality alone is insufficient for singular descriptor realizations (Megawati et al., 2015).

Weighted finite automata replace transition graphs with linear operators. A linear bisimulation is an invariant subspace $u'Rv'$2 contained in the kernel of the final functional. Its largest instance identifies states that realize the same weighted language. A quantitative extension defines a seminorm by the fixed point:

$u'Rv'$3

When $u'Rv'$4, where $u'Rv'$5 is the joint spectral radius, the fixed point exists uniquely. Its kernel is exactly the largest linear bisimulation, while its induced pseudometric measures discounted worst-case output discrepancy over all infinite input words. The metric is continuous under suitable parameter convergence, supports spectral-learning error analysis, and has an undecidable threshold problem in general (Balle et al., 2017).

Neural-network bisimulation adapts the same idea to layered computation. A partition of neurons is an exact $u'Rv'$6-bisimulation when neurons in the same block have equal activation functions, equal biases, and equal total incoming weight from every predecessor block. The quotient network replaces each block by one neuron and preserves the input-output function. The coarsest exact partition is computed by the MinNN refinement algorithm. Approximate $u'Rv'$7-$u'Rv'$8-bisimulation permits bounded bias and pre-sum discrepancies, yielding a smaller quotient with an explicit semantic-error bound depending on $u'Rv'$9, layer depth, activation Lipschitz constants, neuron counts, and weight magnitudes (Prabhakar, 2021).

For Feller–Dynkin processes, ordinary fixed-time kernel comparison is inadequate because path events such as hitting and absorption may distinguish states with identical one-time distributions. A trajectory-based bisimulation instead requires equality of probabilities for all measurable trajectory events invariant under pointwise replacement by related trajectories. This definition specializes to standard discrete-time bisimulation through a clock extension and has an equivalent quotient formulation using FD-homomorphisms and FD-cospans (Chen et al., 2019).

6. Verification, minimization, and computational complexity

Bisimulation supports quotient construction whenever the relation is an equivalence compatible with the transition structure. In fuzzy transition systems, the quotient aggregates transition degrees by suprema. In nondeterministic automata, uniform forward bisimulations correspond to isomorphisms between factor automata obtained by quotienting with the greatest forward bisimulation equivalences. In neural networks, quotienting merges neurons while preserving layerwise semantics. In guarded recursive types, final-coalgebra semantics provides a canonical behavioral quotient up to path equality.

The computational complexity depends strongly on the representation and system class. For finite trees, bisimulation is L-complete under pointer representation and NC$$uRv\land u\xrightarrow{a}u' \Longrightarrow \exists v'.\;v\xrightarrow{a}v'\land u'Rv',$$0-complete under bracket-term representation. If one input is a tree and the other is a general graph, bisimulation is in AC$$uRv\land u\xrightarrow{a}u' \Longrightarrow \exists v'.\;v\xrightarrow{a}v'\land u'Rv',$$1 and NL-hard, while the exact complexity remains open. Simulation is P-complete on bounded path-width graphs and between a tree and a general graph. These results show that bisimulation and simulation can have sharply different complexity profiles even on structurally restricted systems (Ganardi et al., 2018).

Symbolic methods avoid explicit state-space construction. For open pNets, FH-bisimulation checks predicate coverage and substitution compatibility over symbolic transition families. For quantum processes, symbolic ground bisimulation uses Boolean constraints and super-operator equivalence. For higher-order programs, PDNF bisimulation removes an unbounded continuation stack from configurations and replaces it with an orbit-finite continuation graph. The resulting stackless LTS is combined with nominal symmetry, on-the-fly saturation, and up-to techniques. For programs with bounded stackless configurations, PDNF bisimulation is decidable and fully abstract for contextual equivalence (Koutavas et al., 2023).

Bisimulation can also be synthesized rather than checked after the fact. Bisimulation Learning targets deterministic, potentially infinite-state systems by learning a finite state classifier, a quotient transition function, and ranking functions for intra-class stuttering. A counterexample-guided inductive synthesis loop alternates between sample-based learning and SMT verification over the entire state space. If verification finds a violating state, that state is added to the sample; if no violation exists, the classifier is certified. The resulting quotient preserves LTL without the next operator and can provide interpretable abstractions for diagnostics and verification (Abate et al., 2024).

The scope of bisimulation is not uniform across domains. Exact equivalence can be too discriminating for implementations that differ only in internal computation, motivating weak and approximate variants. Approximate weak quantum bisimulation remains difficult because errors can accumulate through internal computations (Feng et al., 2010). Distribution-based probabilistic bisimulation may sacrifice compositionality under unrestricted schedulers (Hermanns et al., 2014). Finite bisimulation quotients need not exist for infinite-state systems, and general quantitative or symbolic checking can be undecidable. Nevertheless, the central methodological principle remains stable: construct a relation or abstraction that preserves observations and is closed under the relevant form of behavioral evolution.