We start our considerations with the following proposition that easily follows from previous results, since fair simulation implies language inclusion :
Proposition 7. Let A , A0. If AfA0 then Lang(A) ⊆ Lang(A0)
This proposition allows us to check validity of a whole set of proposed changes to an automaton at once. To this end we could check whether the quotient of A with respect to fair simulation is equivalent to the original automaton. Whenever the check succeeds we now that all merges are correct. However, if it fails we would know nothing. We will generalize this proposition in the following to obtain a more refined check.
The first lemma that we need is a generalization of the transitivity of fair simulation: Lemma 3. Let A = (S, I, R, Ω), A0 = (S0, I0, R0, Ω0) be parity automata. If s(A,A)f s0 and s0(A,Af 0)s00, then s(A,Af 0)s00.
Proof sketch. The proof of Lemma 1 remains unchanged for this case.
Now we can formulate the following theorem that states that we can safely replace any transition from s to a transition to t for fair-simulation equivalent states t if state t in the modified automaton still fair simulates his counterpart in the unmodified automaton.
Theorem 8. Let A be a parity automaton, let s, t ∈ S such that s 6= t, s≈(A,A)f t. If t≈(A,As→t)
f t then any state in As→t is fair simulation equivalent to the state of the same name in A.
Proof. We denote with t0 ∈ Ss→t the state corresponding to t ∈ S. We first show one direction, the other direction can be shown analogously. More specifically, let t0(As→t,A)
f t. We show that this is enough to guarantee that any state in As→t is fair simulated by the state of the same name in A. To do this, let p0(0)∈ As→t be any state in As→t and p(0) ∈ S be the corresponding state. We want to show that Duplicator
3.7 Fair Simulation for Parity Automata
has a winning strategy in G(A,As→t)
f p
0(0), p(0). The critical points in this case is that t0 is visited in the simulation game, since transitions may not be part of the original automaton.
Since s and t are fair simulation equivalent in the original automaton, we have
t(A,A)f s. Thus, by transitivity, we have t0(As→t,A)
f s. Let γs be the strategy to show t0(As→t,A)
f s, and γt be the strategy to show t
0(As→t,A)
f t. Intuitively, as long as t
0 is
not visited by Spoiler in G(A,As→t
f t
0(0), p(0), Duplicator simply takes as successor the corresponding state from the original automaton. However, if at some point this is not the case, according to the definition of R0, the original automaton has a transition that ends in s or ends in t. But then, we can continue the play with one of the strategies γs or γt. To do this, Duplicator uses a memory variable τ . At the beginning, we set τ = √. Now assume, we are in state (p0(i), p(i)) and Spoiler chooses transition
(p0(i), α(i), p0(i+1)). The next value of τ , denoted withτ0 is determined by:
τ0 = √ if τ =√∧ p0(i+1) 6= t0
s if τ = s ∨ p0(i+1) = t0∧ (p(i), α(i), s) ∈ R t if τ = t ∨ p0(i+1) = t0∧ (p(i), α(i), t) ∈ R The strategy is now defined as follows:
γ(p(i)a(i)p0(i+1)) =
(
p(i+1) if τ0 =√
γτ0(p(i), a(i), p0(i+1)) else
Notice that γ0is well defined, because when τ =√∧τ0 6=√for the first time i, the run π0 = p0(0). . . p0(i)that is induced by Spoiler during the play must have visited t0, i. e. we have p0(i)= t0. This implies that either (p(i−1), α(i−1), s) ∈ R0 or (p(i−1), α(i−1), t) ∈ R0. After that point, the strategy simply mimics one of the strategies γs or γt. Thus γ is winning since both strategies are winning and the winning condition of fair simulation does not depend on a finite prefix.
The other direction is shown analogously by assuming that t(A,As→t)
f t
0 and showing that then any state in the original automaton is fair simulated by the state of the same name in the minimized automaton.
This theorem seems to be very powerful. But it has one drawback that is discussed in the following: Let % be a selection function that selects t as a representative for an equivalence class. Assume that in A÷% some state r is reachable from t that is wrongly merged with some state q. This means that the language accepted from r has changed and might potentially change the language accepted from t on. In some (although very unlikely but still possible) cases it might now happen that when we redo the merge of r and q, we might destroy the fair simulation equivalence of t with its counterpart in the original automaton.
So at first sight it seems that we need to check each merge individually. However, this is not the case. If from t only states are reachable that pass the check of Theo- rem 8, we can be sure that the subautomaton that is reachable from %(t) will never again change and thus this merge is indeed correct. This is captured in the following corollary.
Corollary 4. Let ≈⊆ ≈(A,A)f , i. e. it holds that if s ≈ t, then s≈(A,A)f . Let % be a canonical selection function for ≈. Let
ζ(s) = ( %(s) if ∀α ∈ Σ∗∀q ∈ S.(%(s), α, %(q)) ∈ R÷% → %(q)≈ (A,A÷%) f %(q) s else
Then, any state in A÷ζ is fair simulation equivalent to the state of the same name in A.
Notice that this check can be done by a simple reachability analysis of the state space, so that we obtain an efficient procedure to check multiple changes at one.