Hint Resolve EQFf (*EQfF*).
Goal forall d e : Frame, d = e -> true = eqF d e.
intros.
elim H.
apply eqF7.
Save eqF_elim.
Goal forall d e : Frame, true = eqF d e -> d = e.
intros.
elim (eqF8 d e).
elim H.
elim eqF5.
apply refl_equal.
Save eqF_intro.
Goal forall d e : Frame, false = eqF d e -> d <> e.
intros.
red in |- *; intro.
cut (forall P : bool -> Prop, P true -> P false); intro L.
apply
(L
(fun P : bool =>
match P return Prop with
| true => True
| false => False
end)).
exact I.
intros.
elimtype (eqF d e = false).
elim H0.
elim eqF7.
assumption.
apply sym_equal.
assumption.
Save eqF_intro'.
(* Below the processes used in the alternating bit protocol are defined *)
Parameter K : one -> proc.
Parameter L : one -> proc.
Parameter S : one -> proc.
Parameter Sn : bit -> proc.
Parameter Sn_d : D -> bit -> proc.
Parameter Tn_d : D -> bit -> proc.
Parameter R : one -> proc.
Parameter Rn : bit -> proc.
Section PROC.
Variable b : bit.
Variable j : one.
Variable d : D.
Axiom
ChanK :
Frame +
(fun x : Frame =>
seq (ia Frame r2 x)
(seq
(alt (seq (ia one int i) (ia Frame s3 x))
(seq (ia one int i) (ia Frame s3 lce)))
(K i))) = K j.
Axiom
ChanL :
frame +
(fun n : frame =>
seq (ia frame r5 n)
(seq
(alt (seq (ia one int i) (ia frame s6 n))
(seq (ia one int i) (ia frame s6 sce)))
(L i))) = L j.

(* Specifications: *)
Axiom ProcS : seq (Sn e0) (seq (Sn e1) (S i)) = S j.
Axiom ProcSn : D + (fun d : D => seq (ia D r1 d) (Sn_d d b)) = Sn b.
Axiom ProcSn_d : seq (ia Frame s2 (Tuple b d)) (Tn_d d b) = Sn_d d b.
Axiom
ProcTn_d :
alt
(seq (alt (ia frame r6 (tuple (toggle b))) (ia frame r6 sce))
(Sn_d d b)) (ia frame r6 (tuple b)) = Tn_d d b.
Axiom ProcR : seq (Rn e1) (seq (Rn e0) (R i)) = R j.
Axiom
ProcRn :
alt
(seq
(alt (D + (fun d : D => ia Frame r3 (Tuple b d))) (ia Frame r3 lce))
(seq (ia frame s5 (tuple b)) (Rn b)))
(D +
(fun d : D =>
seq (ia Frame r3 (Tuple (toggle b) d))
(seq (ia D s4 d) (ia frame s5 (tuple (toggle b)))))) =
Rn b.