From Coq Require Import Program.Equality.
From VLSM.Lib Require Import SsrExport Traces.[Loading ML file ssrmatching_plugin.cmxs (using legacy method) ... done]
[Loading ML file ssreflect_plugin.cmxs (using legacy method) ... done]

Set Implicit Arguments.
Unset Strict Implicit.
Import Prenex Implicits.

Utility: Properties of Possibly-Infinite Traces

The property encodings and many specific properties are adapted from the paper A Hoare logic for the coinductive trace-based big-step semantics of While .

Section sec_trace_properties.

Context {A B : Type}.

#[local] Notation trace := (@trace A B).

We want to reason about trace properties that do not distinguish bisimilar traces; these are called setoid properties.

Definition setoidT (p : trace -> Prop) :=
forall tr0, p tr0 -> forall tr1, bisim tr0 tr1 -> p tr1.

Definition propT := { p : trace -> Prop | setoidT p }.

Infiniteness property

CoInductive infiniteT : trace -> Prop :=
| infiniteT_delay : forall a b tr,
   infiniteT tr ->
   infiniteT (Tcons a b tr).

Lemma infiniteT_setoidT : setoidT infiniteT.A, B: Type
setoidT infiniteT
Proof.A, B: Type
setoidT infiniteT
cofix CIH.A, B: Type
CIH: setoidT infiniteT
setoidT infiniteT
move => tr0 h0 tr1 h1; invs h0; invs h1.A, B: Type
CIH: setoidT infiniteT
a: A
b: B
tr, tr': trace
H: infiniteT tr
H4: bisim tr tr'
infiniteT (Tcons a b tr')
exact: (infiniteT_delay a b (CIH _ H _ H4)).
Qed.

Definition InfiniteT : propT :=
exist _ (fun tr => infiniteT tr) infiniteT_setoidT.

Lemma infiniteT_cons : forall a b tr,
 infiniteT (Tcons a b tr) -> infiniteT tr.A, B: Type
forall (a : A) (b : B) (tr : trace),
infiniteT (Tcons a b tr) -> infiniteT tr
Proof.A, B: Type
forall (a : A) (b : B) (tr : trace),
infiniteT (Tcons a b tr) -> infiniteT tr
by move => a b tr Hinf; inversion Hinf.
Qed.

Lemma infiniteT_trace_append :
 forall tr, infiniteT tr -> forall tr', infiniteT (tr' +++ tr).A, B: Type
forall tr : trace,
infiniteT tr ->
forall tr' : trace, infiniteT (tr' +++ tr)
Proof.A, B: Type
forall tr : trace,
infiniteT tr ->
forall tr' : trace, infiniteT (tr' +++ tr)
cofix CIH.A, B: Type
CIH: forall tr : trace, infiniteT tr -> forall tr' : trace, infiniteT (tr' +++ tr)
forall tr : trace,
infiniteT tr ->
forall tr' : trace, infiniteT (tr' +++ tr)
move => tr Htr.A, B: Type
CIH: forall tr : trace, infiniteT tr -> forall tr' : trace, infiniteT (tr' +++ tr)
tr: trace
Htr: infiniteT tr
forall tr' : trace, infiniteT (tr' +++ tr)
case => [a | a b tr']; first by rewrite trace_append_nil.A, B: Type
CIH: forall tr : trace, infiniteT tr -> forall tr' : trace, infiniteT (tr' +++ tr)
tr: trace
Htr: infiniteT tr
a: A
b: B
tr': trace
infiniteT (Tcons a b tr' +++ tr)
rewrite trace_append_cons.A, B: Type
CIH: forall tr : trace, infiniteT tr -> forall tr' : trace, infiniteT (tr' +++ tr)
tr: trace
Htr: infiniteT tr
a: A
b: B
tr': trace
infiniteT (Tcons a b (tr' +++ tr))
exact/infiniteT_delay/CIH.
Qed.

Lemma trace_append_infiniteT :
 forall tr, infiniteT tr -> forall tr', infiniteT (tr +++ tr').A, B: Type
forall tr : trace,
infiniteT tr ->
forall tr' : trace, infiniteT (tr +++ tr')
Proof.A, B: Type
forall tr : trace,
infiniteT tr ->
forall tr' : trace, infiniteT (tr +++ tr')
cofix CIH.A, B: Type
CIH: forall tr : trace, infiniteT tr -> forall tr' : trace, infiniteT (tr +++ tr')
forall tr : trace,
infiniteT tr ->
forall tr' : trace, infiniteT (tr +++ tr')
case => [a | a b tr0] Hinf; inversion Hinf => tr'; subst.A, B: Type
CIH: forall tr : trace, infiniteT tr -> forall tr' : trace, infiniteT (tr +++ tr')
a: A
b: B
tr0: trace
Hinf: infiniteT (Tcons a b tr0)
H0: infiniteT tr0
tr': trace
infiniteT (Tcons a b tr0 +++ tr')
rewrite trace_append_cons.A, B: Type
CIH: forall tr : trace, infiniteT tr -> forall tr' : trace, infiniteT (tr +++ tr')
a: A
b: B
tr0: trace
Hinf: infiniteT (Tcons a b tr0)
H0: infiniteT tr0
tr': trace
infiniteT (Tcons a b (tr0 +++ tr'))
exact/infiniteT_delay/CIH.
Qed.

Finiteness property

Inductive finiteT : trace -> Prop :=
| finiteT_nil : forall a,
   finiteT (Tnil a)
| finiteT_delay : forall (a : A) (b : B) tr,
   finiteT tr ->
   finiteT (Tcons a b tr).

Lemma finiteT_setoidT : setoidT finiteT.A, B: Type
setoidT finiteT
Proof.A, B: Type
setoidT finiteT
move => tr1; elim => [a | a b tr1' Hfin IH] tr2 h0; invs h0.A, B: Type
tr1: trace
a: A
finiteT (Tnil a)
A, B: Type
tr1: trace
a: A
b: B
tr1': trace
Hfin: finiteT tr1'
IH: forall tr1 : trace, bisim tr1' tr1 -> finiteT tr1
tr': trace
H3: bisim tr1' tr'
finiteT (Tcons a b tr')
-A, B: Type
tr1: trace
a: A
finiteT (Tnil a)
A, B: Type
tr1: trace
a: A
b: B
tr1': trace
Hfin: finiteT tr1'
IH: forall tr1 : trace, bisim tr1' tr1 -> finiteT tr1
tr': trace
H3: bisim tr1' tr'
finiteT (Tcons a b tr') exact: finiteT_nil.A, B: Type
tr1: trace
a: A
b: B
tr1': trace
Hfin: finiteT tr1'
IH: forall tr1 : trace, bisim tr1' tr1 -> finiteT tr1
tr': trace
H3: bisim tr1' tr'
finiteT (Tcons a b tr')
-A, B: Type
tr1: trace
a: A
b: B
tr1': trace
Hfin: finiteT tr1'
IH: forall tr1 : trace, bisim tr1' tr1 -> finiteT tr1
tr': trace
H3: bisim tr1' tr'
finiteT (Tcons a b tr') exact/finiteT_delay/IH.
Qed.

Definition FiniteT : propT :=
exist _ (fun tr => finiteT tr) finiteT_setoidT.

Lemma invert_finiteT_delay (a : A) (b : B) (tr : trace)
 (h : finiteT (Tcons a b tr)) : finiteT tr.A, B: Type
a: A
b: B
tr: trace
h: finiteT (Tcons a b tr)
finiteT tr
Proof.A, B: Type
a: A
b: B
tr: trace
h: finiteT (Tcons a b tr)
finiteT tr by inversion h. Defined.

Equality coincides with bisimilarity for finite traces.

Lemma finiteT_bisim_eq : forall tr,
 finiteT tr -> forall tr', bisim tr tr' -> tr = tr'.A, B: Type
forall tr : trace,
finiteT tr ->
forall tr' : trace, bisim tr tr' -> tr = tr'
Proof.A, B: Type
forall tr : trace,
finiteT tr ->
forall tr' : trace, bisim tr tr' -> tr = tr'
move => tr; elim => [a tr' | a b tr0 Hfin IH tr'] Hbis; invs Hbis => //.A, B: Type
tr: trace
a: A
b: B
tr0: trace
Hfin: finiteT tr0
IH: forall tr' : trace, bisim tr0 tr' -> tr0 = tr'
tr'0: trace
H3: bisim tr0 tr'0
Tcons a b tr0 = Tcons a b tr'0
by rewrite (IH _ H3).
Qed.

Basic connections between finiteness and infiniteness.

Lemma finiteT_infiniteT_not : forall tr,
 finiteT tr -> infiniteT tr -> False.A, B: Type
forall tr : trace, finiteT tr -> infiniteT tr -> False
Proof.A, B: Type
forall tr : trace, finiteT tr -> infiniteT tr -> False
by move => tr; elim => [a | a b tr' Hfin IH] Hinf; inversion Hinf.
Qed.

Lemma not_finiteT_infiniteT : forall tr,
 ~ finiteT tr -> infiniteT tr.A, B: Type
forall tr : trace, ~ finiteT tr -> infiniteT tr
Proof.A, B: Type
forall tr : trace, ~ finiteT tr -> infiniteT tr
cofix CIH.A, B: Type
CIH: forall tr : trace, ~ finiteT tr -> infiniteT tr
forall tr : trace, ~ finiteT tr -> infiniteT tr
case => [a | a b tr] Hfin; first by case: Hfin; apply: finiteT_nil.A, B: Type
CIH: forall tr : trace, ~ finiteT tr -> infiniteT tr
a: A
b: B
tr: trace
Hfin: ~ finiteT (Tcons a b tr)
infiniteT (Tcons a b tr)
apply: infiniteT_delay.A, B: Type
CIH: forall tr : trace, ~ finiteT tr -> infiniteT tr
a: A
b: B
tr: trace
Hfin: ~ finiteT (Tcons a b tr)
infiniteT tr
apply: CIH => Hinf.A, B: Type
a: A
b: B
tr: trace
Hfin: ~ finiteT (Tcons a b tr)
Hinf: finiteT tr
False
case: Hfin.A, B: Type
a: A
b: B
tr: trace
Hinf: finiteT tr
finiteT (Tcons a b tr)
exact: finiteT_delay.
Qed.

Final element properties

Inductive finalTA : trace -> A -> Prop :=
| finalTA_nil : forall a,
   finalTA (Tnil a) a
| finalTA_delay : forall a b a' tr,
   finalTA tr a' ->
   finalTA (Tcons a b tr) a'.

Inductive finalTB : trace -> B -> Prop :=
| finalTB_nil : forall a b a',
   finalTB (Tcons a b (Tnil a')) b
| finalTB_delay : forall a b b' tr,
   finalTB tr b' ->
   finalTB (Tcons a b tr) b'.

Lemma finalTA_finiteT : forall tr a, finalTA tr a -> finiteT tr.A, B: Type
forall (tr : trace) (a : A),
finalTA tr a -> finiteT tr
Proof.A, B: Type
forall (tr : trace) (a : A),
finalTA tr a -> finiteT tr
move => tr a; elim => [a1 | a1 b a2 tr' Hfinal IH].A, B: Type
tr: trace
a, a1: A
finiteT (Tnil a1)
A, B: Type
tr: trace
a, a1: A
b: B
a2: A
tr': trace
Hfinal: finalTA tr' a2
IH: finiteT tr'
finiteT (Tcons a1 b tr')
-A, B: Type
tr: trace
a, a1: A
finiteT (Tnil a1)
A, B: Type
tr: trace
a, a1: A
b: B
a2: A
tr': trace
Hfinal: finalTA tr' a2
IH: finiteT tr'
finiteT (Tcons a1 b tr') exact: finiteT_nil.A, B: Type
tr: trace
a, a1: A
b: B
a2: A
tr': trace
Hfinal: finalTA tr' a2
IH: finiteT tr'
finiteT (Tcons a1 b tr')
-A, B: Type
tr: trace
a, a1: A
b: B
a2: A
tr': trace
Hfinal: finalTA tr' a2
IH: finiteT tr'
finiteT (Tcons a1 b tr') exact/finiteT_delay/IH.
Qed.

Lemma finalTB_finiteT : forall tr b, finalTB tr b -> finiteT tr.A, B: Type
forall (tr : trace) (b : B),
finalTB tr b -> finiteT tr
Proof.A, B: Type
forall (tr : trace) (b : B),
finalTB tr b -> finiteT tr
move => tr b; elim => [a1 b1 a2 | a1 b1 b2 a2 Hfin IH].A, B: Type
tr: trace
b: B
a1: A
b1: B
a2: A
finiteT (Tcons a1 b1 (Tnil a2))
A, B: Type
tr: trace
b: B
a1: A
b1, b2: B
a2: trace
Hfin: finalTB a2 b2
IH: finiteT a2
finiteT (Tcons a1 b1 a2)
-A, B: Type
tr: trace
b: B
a1: A
b1: B
a2: A
finiteT (Tcons a1 b1 (Tnil a2))
A, B: Type
tr: trace
b: B
a1: A
b1, b2: B
a2: trace
Hfin: finalTB a2 b2
IH: finiteT a2
finiteT (Tcons a1 b1 a2) exact/finiteT_delay/finiteT_nil.A, B: Type
tr: trace
b: B
a1: A
b1, b2: B
a2: trace
Hfin: finalTB a2 b2
IH: finiteT a2
finiteT (Tcons a1 b1 a2)
-A, B: Type
tr: trace
b: B
a1: A
b1, b2: B
a2: trace
Hfin: finalTB a2 b2
IH: finiteT a2
finiteT (Tcons a1 b1 a2) exact: finiteT_delay.
Qed.

Fixpoint finalA (tr : trace) (h : finiteT tr) {struct h} : A :=
match tr as tr' return (finiteT tr' -> A) with
| Tnil a => fun _ => a
| Tcons a b tr => fun h => finalA (invert_finiteT_delay h)
end h.

Lemma finiteT_finalTA : forall tr (h : finiteT tr),
 finalTA tr (finalA h).A, B: Type
forall (tr : trace) (h : finiteT tr),
finalTA tr (finalA h)
Proof.A, B: Type
forall (tr : trace) (h : finiteT tr),
finalTA tr (finalA h)
refine (fix IH tr h {struct h} := _).A, B: Type
IH: forall (tr : trace) (h : finiteT tr),
finalTA tr (finalA h)
tr: trace
h: finiteT tr
finalTA tr (finalA h)
case: tr h => [a | a b tr] h; dependent inversion h => /=.A, B: Type
IH: forall (tr : trace) (h : finiteT tr),
finalTA tr (finalA h)
a: A
h: finiteT (Tnil a)
a0: A
H0: a0 = a
finalTA (Tnil a) a
A, B: Type
IH: forall (tr : trace) (h : finiteT tr),
finalTA tr (finalA h)
a: A
b: B
tr: trace
h: finiteT (Tcons a b tr)
a0: A
b0: B
tr0: trace
f: finiteT tr
H0: a0 = a
H1: b0 = b
H2: tr0 = tr
finalTA (Tcons a b tr)
  (finalA
     (eq_ind_r
        (fun _ : A =>
         b = b -> tr = tr -> finiteT tr -> finiteT tr)
        (fun H1 : b = b =>
         eq_ind_r
           (fun _ : B =>
            tr = tr -> finiteT tr -> finiteT tr)
           (fun H2 : tr = tr =>
            eq_ind_r
              (fun t : trace =>
               finiteT t -> finiteT tr)
              (fun H0 : finiteT tr => H0) H2) H1)
        eq_refl eq_refl eq_refl f))
-A, B: Type
IH: forall (tr : trace) (h : finiteT tr),
finalTA tr (finalA h)
a: A
h: finiteT (Tnil a)
a0: A
H0: a0 = a
finalTA (Tnil a) a
A, B: Type
IH: forall (tr : trace) (h : finiteT tr),
finalTA tr (finalA h)
a: A
b: B
tr: trace
h: finiteT (Tcons a b tr)
a0: A
b0: B
tr0: trace
f: finiteT tr
H0: a0 = a
H1: b0 = b
H2: tr0 = tr
finalTA (Tcons a b tr)
  (finalA
     (eq_ind_r
        (fun _ : A =>
         b = b -> tr = tr -> finiteT tr -> finiteT tr)
        (fun H1 : b = b =>
         eq_ind_r
           (fun _ : B =>
            tr = tr -> finiteT tr -> finiteT tr)
           (fun H2 : tr = tr =>
            eq_ind_r
              (fun t : trace =>
               finiteT t -> finiteT tr)
              (fun H0 : finiteT tr => H0) H2) H1)
        eq_refl eq_refl eq_refl f)) exact: finalTA_nil.A, B: Type
IH: forall (tr : trace) (h : finiteT tr),
finalTA tr (finalA h)
a: A
b: B
tr: trace
h: finiteT (Tcons a b tr)
a0: A
b0: B
tr0: trace
f: finiteT tr
H0: a0 = a
H1: b0 = b
H2: tr0 = tr
finalTA (Tcons a b tr)
  (finalA
     (eq_ind_r
        (fun _ : A =>
         b = b -> tr = tr -> finiteT tr -> finiteT tr)
        (fun H1 : b = b =>
         eq_ind_r
           (fun _ : B =>
            tr = tr -> finiteT tr -> finiteT tr)
           (fun H2 : tr = tr =>
            eq_ind_r
              (fun t : trace =>
               finiteT t -> finiteT tr)
              (fun H0 : finiteT tr => H0) H2) H1)
        eq_refl eq_refl eq_refl f))
-A, B: Type
IH: forall (tr : trace) (h : finiteT tr),
finalTA tr (finalA h)
a: A
b: B
tr: trace
h: finiteT (Tcons a b tr)
a0: A
b0: B
tr0: trace
f: finiteT tr
H0: a0 = a
H1: b0 = b
H2: tr0 = tr
finalTA (Tcons a b tr)
  (finalA
     (eq_ind_r
        (fun _ : A =>
         b = b -> tr = tr -> finiteT tr -> finiteT tr)
        (fun H1 : b = b =>
         eq_ind_r
           (fun _ : B =>
            tr = tr -> finiteT tr -> finiteT tr)
           (fun H2 : tr = tr =>
            eq_ind_r
              (fun t : trace =>
               finiteT t -> finiteT tr)
              (fun H0 : finiteT tr => H0) H2) H1)
        eq_refl eq_refl eq_refl f)) exact: finalTA_delay.
Qed.

Lemma finalTA_hd_append_trace : forall tr0 a,
 finalTA tr0 a -> forall tr1, hd tr1 = a ->
 hd (tr0 +++ tr1) = hd tr0.A, B: Type
forall (tr0 : trace) (a : A),
finalTA tr0 a ->
forall tr1 : trace,
hd tr1 = a -> hd (tr0 +++ tr1) = hd tr0
Proof.A, B: Type
forall (tr0 : trace) (a : A),
finalTA tr0 a ->
forall tr1 : trace,
hd tr1 = a -> hd (tr0 +++ tr1) = hd tr0
by move => tr a; elim => {tr a} [a tr <- | a b a' tr Hfinal IH tr'] //=.
Qed.

Basic trace properties and connectives

Definition ttT : trace -> Prop := fun tr => True.

Lemma ttT_setoidT : setoidT ttT.A, B: Type
setoidT ttT
Proof.A, B: Type
setoidT ttT by []. Qed.

Definition TtT : propT :=
exist _ ttT ttT_setoidT.

Definition ffT : trace -> Prop := fun tr => False.

Lemma ffT_setoidT : setoidT ffT.A, B: Type
setoidT ffT
Proof.A, B: Type
setoidT ffT by []. Qed.

Definition FfT : propT :=
exist _ ffT ffT_setoidT.

Definition notT (p : trace -> Prop) : trace -> Prop := fun tr => ~ p tr.

Lemma notT_setoidT : forall p, setoidT p -> setoidT (notT p).A, B: Type
forall p : trace -> Prop,
setoidT p -> setoidT (notT p)
Proof.A, B: Type
forall p : trace -> Prop,
setoidT p -> setoidT (notT p)
move => p hp tr h1 tr' h2 h3.A, B: Type
p: trace -> Prop
hp: setoidT p
tr: trace
h1: notT p tr
tr': trace
h2: bisim tr tr'
h3: p tr'
False
apply: h1.A, B: Type
p: trace -> Prop
hp: setoidT p
tr, tr': trace
h2: bisim tr tr'
h3: p tr'
p tr apply: hp _ h3 _ (bisim_sym h2).
Qed.

Definition NotT (p : propT) : propT :=
let: exist f hf := p in
exist _ (notT f) (notT_setoidT hf).

Definition satisfyT (p : propT) : trace -> Prop :=
fun tr => let: exist f0 h0 := p in f0 tr.

Program Definition ExT {T : Type} (p : T -> propT) : propT :=
exist _ (fun tr => exists x, satisfyT (p x) tr) _.
Next Obligation.A, B, T: Type
p: T -> propT
setoidT
  (fun tr : trace => exists x : T, satisfyT (p x) tr)
Proof.A, B, T: Type
p: T -> propT
setoidT
  (fun tr : trace => exists x : T, satisfyT (p x) tr)
move => tr0 [x h0] tr1 h1.A, B, T: Type
p: T -> propT
tr0: trace
x: T
h0: satisfyT (p x) tr0
tr1: trace
h1: bisim tr0 tr1
exists x : T, satisfyT (p x) tr1 exists x.A, B, T: Type
p: T -> propT
tr0: trace
x: T
h0: satisfyT (p x) tr0
tr1: trace
h1: bisim tr0 tr1
satisfyT (p x) tr1
case: (p x) h0 => [f0 h2] /= h0.A, B, T: Type
p: T -> propT
tr0: trace
x: T
tr1: trace
h1: bisim tr0 tr1
f0: trace -> Prop
h2: setoidT f0
h0: f0 tr0
f0 tr1
exact: h2 _ h0 _ h1.
Defined.

Lemma andT_setoidT : forall f0 f1,
 setoidT f0 -> setoidT f1 ->
 setoidT (fun tr => f0 tr /\ f1 tr).A, B: Type
forall f0 f1 : trace -> Prop,
setoidT f0 ->
setoidT f1 ->
setoidT (fun tr : trace => f0 tr /\ f1 tr)
Proof.A, B: Type
forall f0 f1 : trace -> Prop,
setoidT f0 ->
setoidT f1 ->
setoidT (fun tr : trace => f0 tr /\ f1 tr)
move => f0 f1 h0 h1 tr0 [h2 h3] tr1 h4; split.A, B: Type
f0, f1: trace -> Prop
h0: setoidT f0
h1: setoidT f1
tr0: trace
h2: f0 tr0
h3: f1 tr0
tr1: trace
h4: bisim tr0 tr1
f0 tr1
A, B: Type
f0, f1: trace -> Prop
h0: setoidT f0
h1: setoidT f1
tr0: trace
h2: f0 tr0
h3: f1 tr0
tr1: trace
h4: bisim tr0 tr1
f1 tr1
-A, B: Type
f0, f1: trace -> Prop
h0: setoidT f0
h1: setoidT f1
tr0: trace
h2: f0 tr0
h3: f1 tr0
tr1: trace
h4: bisim tr0 tr1
f0 tr1
A, B: Type
f0, f1: trace -> Prop
h0: setoidT f0
h1: setoidT f1
tr0: trace
h2: f0 tr0
h3: f1 tr0
tr1: trace
h4: bisim tr0 tr1
f1 tr1 exact: h0 _ h2 _ h4.A, B: Type
f0, f1: trace -> Prop
h0: setoidT f0
h1: setoidT f1
tr0: trace
h2: f0 tr0
h3: f1 tr0
tr1: trace
h4: bisim tr0 tr1
f1 tr1
-A, B: Type
f0, f1: trace -> Prop
h0: setoidT f0
h1: setoidT f1
tr0: trace
h2: f0 tr0
h3: f1 tr0
tr1: trace
h4: bisim tr0 tr1
f1 tr1 exact: h1 _ h3 _ h4.
Qed.

Definition AndT (p1 p2 : propT) : propT :=
let: exist f0 h0 := p1 in
let: exist f1 h1 := p2 in
exist _ (fun tr => f0 tr /\ f1 tr) (andT_setoidT h0 h1).

#[local] Infix "andT" := AndT (at level 60, right associativity).Identifier 'andT' now a keyword

Lemma orT_setoidT : forall f0 f1,
 setoidT f0 -> setoidT f1 ->
 setoidT (fun tr => f0 tr \/ f1 tr).A, B: Type
forall f0 f1 : trace -> Prop,
setoidT f0 ->
setoidT f1 ->
setoidT (fun tr : trace => f0 tr \/ f1 tr)
Proof.A, B: Type
forall f0 f1 : trace -> Prop,
setoidT f0 ->
setoidT f1 ->
setoidT (fun tr : trace => f0 tr \/ f1 tr)
move => f0 f1 h0 h1 tr0 [h2 | h2] tr1 h3.A, B: Type
f0, f1: trace -> Prop
h0: setoidT f0
h1: setoidT f1
tr0: trace
h2: f0 tr0
tr1: trace
h3: bisim tr0 tr1
f0 tr1 \/ f1 tr1
A, B: Type
f0, f1: trace -> Prop
h0: setoidT f0
h1: setoidT f1
tr0: trace
h2: f1 tr0
tr1: trace
h3: bisim tr0 tr1
f0 tr1 \/ f1 tr1
-A, B: Type
f0, f1: trace -> Prop
h0: setoidT f0
h1: setoidT f1
tr0: trace
h2: f0 tr0
tr1: trace
h3: bisim tr0 tr1
f0 tr1 \/ f1 tr1
A, B: Type
f0, f1: trace -> Prop
h0: setoidT f0
h1: setoidT f1
tr0: trace
h2: f1 tr0
tr1: trace
h3: bisim tr0 tr1
f0 tr1 \/ f1 tr1 by left; apply: h0 _ h2 _ h3.A, B: Type
f0, f1: trace -> Prop
h0: setoidT f0
h1: setoidT f1
tr0: trace
h2: f1 tr0
tr1: trace
h3: bisim tr0 tr1
f0 tr1 \/ f1 tr1
-A, B: Type
f0, f1: trace -> Prop
h0: setoidT f0
h1: setoidT f1
tr0: trace
h2: f1 tr0
tr1: trace
h3: bisim tr0 tr1
f0 tr1 \/ f1 tr1 by right; apply: h1 _ h2 _ h3.
Qed.

Definition OrT (p1 p2 : propT) : propT :=
let: exist f0 h0 := p1 in
let: exist f1 h1 := p2 in
exist _ (fun tr => f0 tr \/ f1 tr) (orT_setoidT h0 h1).

#[local] Infix "orT" := OrT (at level 60, right associativity).Identifier 'orT' now a keyword

Definition propT_imp (p1 p2 : propT) : Prop :=
forall tr, satisfyT p1 tr -> satisfyT p2 tr.

#[local] Infix "=>>" := propT_imp (at level 60, right associativity).

Lemma propT_imp_conseq_L : forall p0 p1 q, p0 =>> p1 -> p1 =>> q -> p0 =>> q.A, B: Type
forall p0 p1 q : propT,
p0 =>> p1 -> p1 =>> q -> p0 =>> q
Proof.A, B: Type
forall p0 p1 q : propT,
p0 =>> p1 -> p1 =>> q -> p0 =>> q
move => [p0 hp0] [p1 hp1] [q hq] h0 h1 tr0 /= h2.A, B: Type
p0: trace -> Prop
hp0: setoidT p0
p1: trace -> Prop
hp1: setoidT p1
q: trace -> Prop
hq: setoidT q
h0: exist (fun p : trace -> Prop => setoidT p) p0 hp0 =>>
exist (fun p : trace -> Prop => setoidT p) p1 hp1
h1: exist (fun p : trace -> Prop => setoidT p) p1 hp1 =>>
exist (fun p : trace -> Prop => setoidT p) q hq
tr0: trace
h2: p0 tr0
q tr0
exact/h1/h0.
Qed.

Lemma propT_imp_conseq_R : forall p q0 q1,
 q0 =>> q1 -> p =>> q0 -> p =>> q1.A, B: Type
forall p q0 q1 : propT,
q0 =>> q1 -> p =>> q0 -> p =>> q1
Proof.A, B: Type
forall p q0 q1 : propT,
q0 =>> q1 -> p =>> q0 -> p =>> q1
move => [p hp] [q0 hq0] [q1 hq1] h0 h1 tr0 /= h2.A, B: Type
p: trace -> Prop
hp: setoidT p
q0: trace -> Prop
hq0: setoidT q0
q1: trace -> Prop
hq1: setoidT q1
h0: exist (fun p : trace -> Prop => setoidT p) q0 hq0 =>>
exist (fun p : trace -> Prop => setoidT p) q1 hq1
h1: exist (fun p : trace -> Prop => setoidT p) p hp =>>
exist (fun p : trace -> Prop => setoidT p) q0 hq0
tr0: trace
h2: p tr0
q1 tr0
exact/h0/h1.
Qed.

Lemma propT_imp_andT : forall p q0 q1,
 p =>> q0 -> p =>> q1 -> p =>> (q0 andT q1).A, B: Type
forall p q0 q1 : propT,
p =>> q0 -> p =>> q1 -> p =>> q0 andT q1
Proof.A, B: Type
forall p q0 q1 : propT,
p =>> q0 -> p =>> q1 -> p =>> q0 andT q1
move => [p hp] [q0 hq0] [q1 hq1] h0 h1 tr0 /= h2.A, B: Type
p: trace -> Prop
hp: setoidT p
q0: trace -> Prop
hq0: setoidT q0
q1: trace -> Prop
hq1: setoidT q1
h0: exist (fun p : trace -> Prop => setoidT p) p hp =>>
exist (fun p : trace -> Prop => setoidT p) q0 hq0
h1: exist (fun p : trace -> Prop => setoidT p) p hp =>>
exist (fun p : trace -> Prop => setoidT p) q1 hq1
tr0: trace
h2: p tr0
q0 tr0 /\ q1 tr0 split.A, B: Type
p: trace -> Prop
hp: setoidT p
q0: trace -> Prop
hq0: setoidT q0
q1: trace -> Prop
hq1: setoidT q1
h0: exist (fun p : trace -> Prop => setoidT p) p hp =>>
exist (fun p : trace -> Prop => setoidT p) q0 hq0
h1: exist (fun p : trace -> Prop => setoidT p) p hp =>>
exist (fun p : trace -> Prop => setoidT p) q1 hq1
tr0: trace
h2: p tr0
q0 tr0
A, B: Type
p: trace -> Prop
hp: setoidT p
q0: trace -> Prop
hq0: setoidT q0
q1: trace -> Prop
hq1: setoidT q1
h0: exist (fun p : trace -> Prop => setoidT p) p hp =>>
exist (fun p : trace -> Prop => setoidT p) q0 hq0
h1: exist (fun p : trace -> Prop => setoidT p) p hp =>>
exist (fun p : trace -> Prop => setoidT p) q1 hq1
tr0: trace
h2: p tr0
q1 tr0
-A, B: Type
p: trace -> Prop
hp: setoidT p
q0: trace -> Prop
hq0: setoidT q0
q1: trace -> Prop
hq1: setoidT q1
h0: exist (fun p : trace -> Prop => setoidT p) p hp =>>
exist (fun p : trace -> Prop => setoidT p) q0 hq0
h1: exist (fun p : trace -> Prop => setoidT p) p hp =>>
exist (fun p : trace -> Prop => setoidT p) q1 hq1
tr0: trace
h2: p tr0
q0 tr0
A, B: Type
p: trace -> Prop
hp: setoidT p
q0: trace -> Prop
hq0: setoidT q0
q1: trace -> Prop
hq1: setoidT q1
h0: exist (fun p : trace -> Prop => setoidT p) p hp =>>
exist (fun p : trace -> Prop => setoidT p) q0 hq0
h1: exist (fun p : trace -> Prop => setoidT p) p hp =>>
exist (fun p : trace -> Prop => setoidT p) q1 hq1
tr0: trace
h2: p tr0
q1 tr0 exact: h0.A, B: Type
p: trace -> Prop
hp: setoidT p
q0: trace -> Prop
hq0: setoidT q0
q1: trace -> Prop
hq1: setoidT q1
h0: exist (fun p : trace -> Prop => setoidT p) p hp =>>
exist (fun p : trace -> Prop => setoidT p) q0 hq0
h1: exist (fun p : trace -> Prop => setoidT p) p hp =>>
exist (fun p : trace -> Prop => setoidT p) q1 hq1
tr0: trace
h2: p tr0
q1 tr0
-A, B: Type
p: trace -> Prop
hp: setoidT p
q0: trace -> Prop
hq0: setoidT q0
q1: trace -> Prop
hq1: setoidT q1
h0: exist (fun p : trace -> Prop => setoidT p) p hp =>>
exist (fun p : trace -> Prop => setoidT p) q0 hq0
h1: exist (fun p : trace -> Prop => setoidT p) p hp =>>
exist (fun p : trace -> Prop => setoidT p) q1 hq1
tr0: trace
h2: p tr0
q1 tr0 exact: h1.
Qed.

Lemma propT_imp_refl : forall p, p =>> p.A, B: Type
forall p : propT, p =>> p
Proof.A, B: Type
forall p : propT, p =>> p by move => p. Qed.

Lemma satisfyT_cont : forall p0 p1,
 p0 =>> p1 -> forall tr, satisfyT p0 tr -> satisfyT p1 tr.A, B: Type
forall p0 p1 : propT,
p0 =>> p1 ->
forall tr : trace, satisfyT p0 tr -> satisfyT p1 tr
Proof.A, B: Type
forall p0 p1 : propT,
p0 =>> p1 ->
forall tr : trace, satisfyT p0 tr -> satisfyT p1 tr
move => [f0 h0] [f1 h1] h2 tr /= h3.A, B: Type
f0: trace -> Prop
h0: setoidT f0
f1: trace -> Prop
h1: setoidT f1
h2: exist (fun p : trace -> Prop => setoidT p) f0 h0 =>>
exist (fun p : trace -> Prop => setoidT p) f1 h1
tr: trace
h3: f0 tr
f1 tr
exact: h2.
Qed.

Lemma propT_imp_trans : forall p q r, p =>> q -> q =>> r -> p =>> r.A, B: Type
forall p q r : propT, p =>> q -> q =>> r -> p =>> r
Proof.A, B: Type
forall p q r : propT, p =>> q -> q =>> r -> p =>> r
move => p q r h0 h1 tr0 h2.A, B: Type
p, q, r: propT
h0: p =>> q
h1: q =>> r
tr0: trace
h2: satisfyT p tr0
satisfyT r tr0
exact/(satisfyT_cont h1)/(satisfyT_cont h0 h2).
Qed.

Lemma OrT_left : forall p1 p2, p1 =>> (p1 orT p2).A, B: Type
forall p1 p2 : propT, p1 =>> p1 orT p2
Proof.A, B: Type
forall p1 p2 : propT, p1 =>> p1 orT p2
by move => [f1 hf1] [f2 hf2] tr /= h1; left.
Qed.

Lemma OrT_right : forall p1 p2, p2 =>> (p1 orT p2).A, B: Type
forall p1 p2 : propT, p2 =>> p1 orT p2
Proof.A, B: Type
forall p1 p2 : propT, p2 =>> p1 orT p2
by move => [f1 hf1] [f2 hf2] tr /= h1; right.
Qed.

Basic trace element properties and connectives

Definition propA := A -> Prop.

Definition ttA : propA := fun a => True.

Definition ffA : propA := fun a => False.

Definition propA_imp (u1 u2 : propA) : Prop := forall a, u1 a -> u2 a.

#[local] Infix "->>" := propA_imp (at level 60, right associativity).

Definition andA (u1 u2 : propA) : propA := fun a => u1 a /\ u2 a.

#[local] Infix "andA" := andA (at level 60, right associativity).Identifier 'andA' now a keyword

Definition exA {T : Type} (u : T -> propA) : propA :=
fun st => exists x, u x st.

Singleton property

Definition singletonT (u : propA) : trace -> Prop :=
fun tr => exists a, u a /\ bisim tr (Tnil a).

Lemma nil_singletonT : forall (u : propA) a, u a -> singletonT u (Tnil a).A, B: Type
forall (u : propA) (a : A),
u a -> singletonT u (Tnil a)
Proof.A, B: Type
forall (u : propA) (a : A),
u a -> singletonT u (Tnil a) by move => u st h0; exists st; split; last by apply: bisim_refl. Qed.

Lemma singletonT_setoidT : forall u, setoidT (singletonT u).A, B: Type
forall u : propA, setoidT (singletonT u)
Proof.A, B: Type
forall u : propA, setoidT (singletonT u)
move => u tr0 [a [h0 h2]] tr1 h1; invs h2; invs h1.A, B: Type
u: propA
a: A
h0: u a
singletonT u (Tnil a)
exact: nil_singletonT.
Qed.

Lemma singletonT_cont : forall u v, u ->> v ->
 forall tr, singletonT u tr -> singletonT v tr.A, B: Type
forall u v : propA,
u ->> v ->
forall tr : trace, singletonT u tr -> singletonT v tr
Proof.A, B: Type
forall u v : propA,
u ->> v ->
forall tr : trace, singletonT u tr -> singletonT v tr
move => u v huv tr0 [a [h0 h1]]; invs h1.A, B: Type
u, v: propA
huv: u ->> v
a: A
h0: u a
singletonT v (Tnil a)
exact/nil_singletonT/huv.
Qed.

Lemma singletonT_nil : forall u a, singletonT u (Tnil a) -> u a.A, B: Type
forall (u : propA) (a : A),
singletonT u (Tnil a) -> u a
Proof.A, B: Type
forall (u : propA) (a : A),
singletonT u (Tnil a) -> u a by move => u st [a [h0 h1]]; invs h1. Qed.

Definition SingletonT (u : propA) : propT :=
exist _ (singletonT u) (@singletonT_setoidT u).

#[local] Notation "[| p |]" := (SingletonT p) (at level 80).

Lemma SingletonT_cont : forall u v, u ->> v -> [|u|] =>> [|v|].A, B: Type
forall u v : propA, u ->> v -> ([|u|]) =>> ([|v|])
Proof.A, B: Type
forall u v : propA, u ->> v -> ([|u|]) =>> ([|v|])
move => u v h0 tr0 [a [h1 h2]]; invs h2.A, B: Type
u, v: propA
h0: u ->> v
a: A
h1: u a
satisfyT ([|v|]) (Tnil a)
exact/nil_singletonT/h0.
Qed.

Duplicate element property

Definition dupT (u : propA) (b : B) : trace -> Prop :=
fun tr => exists a, u a /\ bisim tr (Tcons a b (Tnil a)).

Lemma dupT_Tcons : forall (u : propA) a b,
 u a -> dupT u b (Tcons a b (Tnil a)).A, B: Type
forall (u : propA) (a : A) (b : B),
u a -> dupT u b (Tcons a b (Tnil a))
Proof.A, B: Type
forall (u : propA) (a : A) (b : B),
u a -> dupT u b (Tcons a b (Tnil a))
move => u a b h.A, B: Type
u: propA
a: A
b: B
h: u a
dupT u b (Tcons a b (Tnil a))
by exists a; split; [apply: h | apply: bisim_refl].
Qed.

Lemma dupT_cont : forall (u0 u1 : propA) b,
 u0 ->> u1 -> forall tr, dupT u0 b tr -> dupT u1 b tr.A, B: Type
forall (u0 u1 : propA) (b : B),
u0 ->> u1 ->
forall tr : trace, dupT u0 b tr -> dupT u1 b tr
Proof.A, B: Type
forall (u0 u1 : propA) (b : B),
u0 ->> u1 ->
forall tr : trace, dupT u0 b tr -> dupT u1 b tr
move => u0 u1 b hu tr [a [h0 h1]]; invs h1; invs H1.A, B: Type
u0, u1: propA
b: B
hu: u0 ->> u1
a: A
h0: u0 a
dupT u1 b (Tcons a b (Tnil a))
exact/dupT_Tcons/hu.
Qed.

Lemma dupT_setoidT : forall u b, setoidT (dupT u b).A, B: Type
forall (u : propA) (b : B), setoidT (dupT u b)
Proof.A, B: Type
forall (u : propA) (b : B), setoidT (dupT u b)
move => u b tr0 [a [h0 h1]] tr1 h2.A, B: Type
u: propA
b: B
tr0: trace
a: A
h0: u a
h1: bisim tr0 (Tcons a b (Tnil a))
tr1: trace
h2: bisim tr0 tr1
dupT u b tr1
invs h1; invs H1; invs h2; invs H3.A, B: Type
u: propA
b: B
a: A
h0: u a
dupT u b (Tcons a b (Tnil a))
exact/dupT_Tcons.
Qed.

Definition DupT (u : propA) (b : B) : propT :=
exist _ (dupT u b) (@dupT_setoidT u b).

#[local] Notation "<< p ; b >>" := (DupT p b) (at level 80).

Lemma DupT_cont : forall u v b, u ->> v -> <<u;b>> =>> <<v;b>>.A, B: Type
forall (u v : propA) (b : B),
u ->> v -> (<< u; b >>) =>> (<< v; b >>)
Proof.A, B: Type
forall (u v : propA) (b : B),
u ->> v -> (<< u; b >>) =>> (<< v; b >>)
move => u v b h0 tr0 /=.A, B: Type
u, v: propA
b: B
h0: u ->> v
tr0: trace
dupT u b tr0 -> dupT v b tr0
exact: dupT_cont.
Qed.

Follows property

The follows property holds for two traces when the first is a prefix of the second, and p holds for the suffix.

CoInductive followsT (p : trace -> Prop) : trace -> trace -> Prop :=
| followsT_nil : forall a tr,
   hd tr = a ->
   p tr ->
   followsT p (Tnil a) tr
| followsT_delay : forall a b tr tr',
   followsT p tr tr' ->
   followsT p (Tcons a b tr) (Tcons a b tr').

Lemma followsT_hd : forall p tr0 tr1, followsT p tr0 tr1 -> hd tr0 = hd tr1.A, B: Type
forall (p : trace -> Prop) (tr0 tr1 : trace),
followsT p tr0 tr1 -> hd tr0 = hd tr1
Proof.A, B: Type
forall (p : trace -> Prop) (tr0 tr1 : trace),
followsT p tr0 tr1 -> hd tr0 = hd tr1 by move => p tr0 tr1 h0; invs h0. Qed.

Definition followsT_dec : forall p tr0 tr1 (h : followsT p tr0 tr1),
 { tr & { a | tr0 = Tnil a /\ hd tr = a /\ p tr } } +
 { tr & { tr' & { a & { b | tr0 = Tcons a b tr /\ tr1 = Tcons a b tr' /\ followsT p tr tr'} } } }.A, B: Type
forall (p : trace -> Prop) (tr0 tr1 : trace),
followsT p tr0 tr1 ->
{tr : trace &
{a : A | tr0 = Tnil a /\ hd tr = a /\ p tr}} +
{tr : trace &
{tr' : trace &
{a : A &
{b : B
| tr0 = Tcons a b tr /\
  tr1 = Tcons a b tr' /\ followsT p tr tr'}}}}
Proof.A, B: Type
forall (p : trace -> Prop) (tr0 tr1 : trace),
followsT p tr0 tr1 ->
{tr : trace &
{a : A | tr0 = Tnil a /\ hd tr = a /\ p tr}} +
{tr : trace &
{tr' : trace &
{a : A &
{b : B
| tr0 = Tcons a b tr /\
  tr1 = Tcons a b tr' /\ followsT p tr tr'}}}}
move => p [a | a b tr0] tr1 h.A, B: Type
p: trace -> Prop
a: A
tr1: trace
h: followsT p (Tnil a) tr1
({tr : trace &
 {a0 : A | Tnil a = Tnil a0 /\ hd tr = a0 /\ p tr}} +
 {tr : trace &
 {tr' : trace &
 {a0 : A &
 {b : B
 | Tnil a = Tcons a0 b tr /\
   tr1 = Tcons a0 b tr' /\ followsT p tr tr'}}}})%type
A, B: Type
p: trace -> Prop
a: A
b: B
tr0, tr1: trace
h: followsT p (Tcons a b tr0) tr1
({tr : trace &
 {a0 : A
 | Tcons a b tr0 = Tnil a0 /\ hd tr = a0 /\ p tr}} +
 {tr : trace &
 {tr' : trace &
 {a0 : A &
 {b0 : B
 | Tcons a b tr0 = Tcons a0 b0 tr /\
   tr1 = Tcons a0 b0 tr' /\ followsT p tr tr'}}}})%type
-A, B: Type
p: trace -> Prop
a: A
tr1: trace
h: followsT p (Tnil a) tr1
({tr : trace &
 {a0 : A | Tnil a = Tnil a0 /\ hd tr = a0 /\ p tr}} +
 {tr : trace &
 {tr' : trace &
 {a0 : A &
 {b : B
 | Tnil a = Tcons a0 b tr /\
   tr1 = Tcons a0 b tr' /\ followsT p tr tr'}}}})%type
A, B: Type
p: trace -> Prop
a: A
b: B
tr0, tr1: trace
h: followsT p (Tcons a b tr0) tr1
({tr : trace &
 {a0 : A
 | Tcons a b tr0 = Tnil a0 /\ hd tr = a0 /\ p tr}} +
 {tr : trace &
 {tr' : trace &
 {a0 : A &
 {b0 : B
 | Tcons a b tr0 = Tcons a0 b0 tr /\
   tr1 = Tcons a0 b0 tr' /\ followsT p tr tr'}}}})%type by left; exists tr1, a; inversion h.A, B: Type
p: trace -> Prop
a: A
b: B
tr0, tr1: trace
h: followsT p (Tcons a b tr0) tr1
({tr : trace &
 {a0 : A
 | Tcons a b tr0 = Tnil a0 /\ hd tr = a0 /\ p tr}} +
 {tr : trace &
 {tr' : trace &
 {a0 : A &
 {b0 : B
 | Tcons a b tr0 = Tcons a0 b0 tr /\
   tr1 = Tcons a0 b0 tr' /\ followsT p tr tr'}}}})%type
-A, B: Type
p: trace -> Prop
a: A
b: B
tr0, tr1: trace
h: followsT p (Tcons a b tr0) tr1
({tr : trace &
 {a0 : A
 | Tcons a b tr0 = Tnil a0 /\ hd tr = a0 /\ p tr}} +
 {tr : trace &
 {tr' : trace &
 {a0 : A &
 {b0 : B
 | Tcons a b tr0 = Tcons a0 b0 tr /\
   tr1 = Tcons a0 b0 tr' /\ followsT p tr tr'}}}})%type case: tr1 h => [a0 | a0 b0 tr1] h.A, B: Type
p: trace -> Prop
a: A
b: B
tr0: trace
a0: A
h: followsT p (Tcons a b tr0) (Tnil a0)
({tr : trace &
 {a0 : A
 | Tcons a b tr0 = Tnil a0 /\ hd tr = a0 /\ p tr}} +
 {tr : trace &
 {tr' : trace &
 {a1 : A &
 {b0 : B
 | Tcons a b tr0 = Tcons a1 b0 tr /\
   Tnil a0 = Tcons a1 b0 tr' /\ followsT p tr tr'}}}})%type
A, B: Type
p: trace -> Prop
a: A
b: B
tr0: trace
a0: A
b0: B
tr1: trace
h: followsT p (Tcons a b tr0) (Tcons a0 b0 tr1)
({tr : trace &
 {a0 : A
 | Tcons a b tr0 = Tnil a0 /\ hd tr = a0 /\ p tr}} +
 {tr : trace &
 {tr' : trace &
 {a1 : A &
 {b1 : B
 | Tcons a b tr0 = Tcons a1 b1 tr /\
   Tcons a0 b0 tr1 = Tcons a1 b1 tr' /\
   followsT p tr tr'}}}})%type
  +A, B: Type
p: trace -> Prop
a: A
b: B
tr0: trace
a0: A
h: followsT p (Tcons a b tr0) (Tnil a0)
({tr : trace &
 {a0 : A
 | Tcons a b tr0 = Tnil a0 /\ hd tr = a0 /\ p tr}} +
 {tr : trace &
 {tr' : trace &
 {a1 : A &
 {b0 : B
 | Tcons a b tr0 = Tcons a1 b0 tr /\
   Tnil a0 = Tcons a1 b0 tr' /\ followsT p tr tr'}}}})%type
A, B: Type
p: trace -> Prop
a: A
b: B
tr0: trace
a0: A
b0: B
tr1: trace
h: followsT p (Tcons a b tr0) (Tcons a0 b0 tr1)
({tr : trace &
 {a0 : A
 | Tcons a b tr0 = Tnil a0 /\ hd tr = a0 /\ p tr}} +
 {tr : trace &
 {tr' : trace &
 {a1 : A &
 {b1 : B
 | Tcons a b tr0 = Tcons a1 b1 tr /\
   Tcons a0 b0 tr1 = Tcons a1 b1 tr' /\
   followsT p tr tr'}}}})%type by left; exists (Tnil a); exists a; inversion h.A, B: Type
p: trace -> Prop
a: A
b: B
tr0: trace
a0: A
b0: B
tr1: trace
h: followsT p (Tcons a b tr0) (Tcons a0 b0 tr1)
({tr : trace &
 {a0 : A
 | Tcons a b tr0 = Tnil a0 /\ hd tr = a0 /\ p tr}} +
 {tr : trace &
 {tr' : trace &
 {a1 : A &
 {b1 : B
 | Tcons a b tr0 = Tcons a1 b1 tr /\
   Tcons a0 b0 tr1 = Tcons a1 b1 tr' /\
   followsT p tr tr'}}}})%type
  +A, B: Type
p: trace -> Prop
a: A
b: B
tr0: trace
a0: A
b0: B
tr1: trace
h: followsT p (Tcons a b tr0) (Tcons a0 b0 tr1)
({tr : trace &
 {a0 : A
 | Tcons a b tr0 = Tnil a0 /\ hd tr = a0 /\ p tr}} +
 {tr : trace &
 {tr' : trace &
 {a1 : A &
 {b1 : B
 | Tcons a b tr0 = Tcons a1 b1 tr /\
   Tcons a0 b0 tr1 = Tcons a1 b1 tr' /\
   followsT p tr tr'}}}})%type by right; exists tr0, tr1, a, b; inversion h.
Defined.

Lemma followsT_setoidT :
  forall (p : trace -> Prop) (hp : forall tr0, p tr0 -> forall tr1, bisim tr0 tr1 -> p tr1),
  forall tr0 tr1, followsT p tr0 tr1 ->
  forall tr2, bisim tr0 tr2 -> forall tr3, bisim tr1 tr3 ->
    followsT p tr2 tr3.A, B: Type
forall p : trace -> Prop,
(forall tr0 : trace,
 p tr0 -> forall tr1 : trace, bisim tr0 tr1 -> p tr1) ->
forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 ->
forall tr3 : trace,
bisim tr1 tr3 -> followsT p tr2 tr3
Proof.A, B: Type
forall p : trace -> Prop,
(forall tr0 : trace,
 p tr0 -> forall tr1 : trace, bisim tr0 tr1 -> p tr1) ->
forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 ->
forall tr3 : trace,
bisim tr1 tr3 -> followsT p tr2 tr3
move => p hp.A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 ->
forall tr3 : trace,
bisim tr1 tr3 -> followsT p tr2 tr3
cofix CIH.A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> forall tr3 : trace, bisim tr1 tr3 -> followsT p tr2 tr3
forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 ->
forall tr3 : trace,
bisim tr1 tr3 -> followsT p tr2 tr3
move => tr0 tr1 h0 tr2 h1 tr3 h2; invs h0.A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> forall tr3 : trace, bisim tr1 tr3 -> followsT p tr2 tr3
tr1, tr2: trace
h1: bisim (Tnil (hd tr1)) tr2
tr3: trace
h2: bisim tr1 tr3
H0: p tr1
followsT p tr2 tr3
A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> forall tr3 : trace, bisim tr1 tr3 -> followsT p tr2 tr3
a: A
b: B
tr, tr', tr2: trace
h1: bisim (Tcons a b tr) tr2
tr3: trace
h2: bisim (Tcons a b tr') tr3
H: followsT p tr tr'
followsT p tr2 tr3
-A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> forall tr3 : trace, bisim tr1 tr3 -> followsT p tr2 tr3
tr1, tr2: trace
h1: bisim (Tnil (hd tr1)) tr2
tr3: trace
h2: bisim tr1 tr3
H0: p tr1
followsT p tr2 tr3
A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> forall tr3 : trace, bisim tr1 tr3 -> followsT p tr2 tr3
a: A
b: B
tr, tr', tr2: trace
h1: bisim (Tcons a b tr) tr2
tr3: trace
h2: bisim (Tcons a b tr') tr3
H: followsT p tr tr'
followsT p tr2 tr3 invs h1.A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> forall tr3 : trace, bisim tr1 tr3 -> followsT p tr2 tr3
tr1, tr3: trace
h2: bisim tr1 tr3
H0: p tr1
followsT p (Tnil (hd tr1)) tr3
A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> forall tr3 : trace, bisim tr1 tr3 -> followsT p tr2 tr3
a: A
b: B
tr, tr', tr2: trace
h1: bisim (Tcons a b tr) tr2
tr3: trace
h2: bisim (Tcons a b tr') tr3
H: followsT p tr tr'
followsT p tr2 tr3 have h0 := bisim_hd h2.A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> forall tr3 : trace, bisim tr1 tr3 -> followsT p tr2 tr3
tr1, tr3: trace
h2: bisim tr1 tr3
H0: p tr1
h0: hd tr1 = hd tr3
followsT p (Tnil (hd tr1)) tr3
A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> forall tr3 : trace, bisim tr1 tr3 -> followsT p tr2 tr3
a: A
b: B
tr, tr', tr2: trace
h1: bisim (Tcons a b tr) tr2
tr3: trace
h2: bisim (Tcons a b tr') tr3
H: followsT p tr tr'
followsT p tr2 tr3 symmetry in h0.A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> forall tr3 : trace, bisim tr1 tr3 -> followsT p tr2 tr3
tr1, tr3: trace
h2: bisim tr1 tr3
H0: p tr1
h0: hd tr3 = hd tr1
followsT p (Tnil (hd tr1)) tr3
A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> forall tr3 : trace, bisim tr1 tr3 -> followsT p tr2 tr3
a: A
b: B
tr, tr', tr2: trace
h1: bisim (Tcons a b tr) tr2
tr3: trace
h2: bisim (Tcons a b tr') tr3
H: followsT p tr tr'
followsT p tr2 tr3
  exact: followsT_nil h0 (hp _ H0 _ h2).A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> forall tr3 : trace, bisim tr1 tr3 -> followsT p tr2 tr3
a: A
b: B
tr, tr', tr2: trace
h1: bisim (Tcons a b tr) tr2
tr3: trace
h2: bisim (Tcons a b tr') tr3
H: followsT p tr tr'
followsT p tr2 tr3
-A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> forall tr3 : trace, bisim tr1 tr3 -> followsT p tr2 tr3
a: A
b: B
tr, tr', tr2: trace
h1: bisim (Tcons a b tr) tr2
tr3: trace
h2: bisim (Tcons a b tr') tr3
H: followsT p tr tr'
followsT p tr2 tr3 invs h2; invs h1.A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> forall tr3 : trace, bisim tr1 tr3 -> followsT p tr2 tr3
a: A
b: B
tr, tr', tr'1, tr'0: trace
H: followsT p tr tr'
H4: bisim tr' tr'0
H5: bisim tr tr'1
followsT p (Tcons a b tr'1) (Tcons a b tr'0)
  exact: (followsT_delay a b (CIH _ _ H _ H5 _ H4)).
Qed.

Lemma followsT_setoidT_L : forall p,
 forall tr0 tr1, followsT p tr0 tr1 ->
 forall tr2, bisim tr0 tr2 ->  followsT p tr2 tr1.A, B: Type
forall (p : trace -> Prop) (tr0 tr1 : trace),
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> followsT p tr2 tr1
Proof.A, B: Type
forall (p : trace -> Prop) (tr0 tr1 : trace),
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> followsT p tr2 tr1
move => p.A, B: Type
p: trace -> Prop
forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> followsT p tr2 tr1 cofix CIH.A, B: Type
p: trace -> Prop
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 -> forall tr2 : trace, bisim tr0 tr2 -> followsT p tr2 tr1
forall tr0 tr1 : trace,
followsT p tr0 tr1 ->
forall tr2 : trace,
bisim tr0 tr2 -> followsT p tr2 tr1 move =>  tr tr0 h0 tr1 h1; invs h0; invs h1.A, B: Type
p: trace -> Prop
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 -> forall tr2 : trace, bisim tr0 tr2 -> followsT p tr2 tr1
tr0: trace
H0: p tr0
followsT p (Tnil (hd tr0)) tr0
A, B: Type
p: trace -> Prop
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 -> forall tr2 : trace, bisim tr0 tr2 -> followsT p tr2 tr1
a: A
b: B
tr2, tr', tr'0: trace
H: followsT p tr2 tr'
H4: bisim tr2 tr'0
followsT p (Tcons a b tr'0) (Tcons a b tr')
-A, B: Type
p: trace -> Prop
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 -> forall tr2 : trace, bisim tr0 tr2 -> followsT p tr2 tr1
tr0: trace
H0: p tr0
followsT p (Tnil (hd tr0)) tr0
A, B: Type
p: trace -> Prop
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 -> forall tr2 : trace, bisim tr0 tr2 -> followsT p tr2 tr1
a: A
b: B
tr2, tr', tr'0: trace
H: followsT p tr2 tr'
H4: bisim tr2 tr'0
followsT p (Tcons a b tr'0) (Tcons a b tr') exact: followsT_nil.A, B: Type
p: trace -> Prop
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 -> forall tr2 : trace, bisim tr0 tr2 -> followsT p tr2 tr1
a: A
b: B
tr2, tr', tr'0: trace
H: followsT p tr2 tr'
H4: bisim tr2 tr'0
followsT p (Tcons a b tr'0) (Tcons a b tr')
-A, B: Type
p: trace -> Prop
CIH: forall tr0 tr1 : trace,
followsT p tr0 tr1 -> forall tr2 : trace, bisim tr0 tr2 -> followsT p tr2 tr1
a: A
b: B
tr2, tr', tr'0: trace
H: followsT p tr2 tr'
H4: bisim tr2 tr'0
followsT p (Tcons a b tr'0) (Tcons a b tr') exact: (followsT_delay a b (CIH _ _ H _ H4)).
Qed.

Lemma followsT_setoidT_R : forall (p : trace -> Prop)
 (hp : forall tr0, p tr0 -> forall tr1, bisim tr0 tr1 -> p tr1),
 forall tr tr0, followsT p tr tr0 ->
 forall tr1, bisim tr0 tr1 -> followsT p tr tr1.A, B: Type
forall p : trace -> Prop,
(forall tr0 : trace,
 p tr0 -> forall tr1 : trace, bisim tr0 tr1 -> p tr1) ->
forall tr tr0 : trace,
followsT p tr tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> followsT p tr tr1
Proof.A, B: Type
forall p : trace -> Prop,
(forall tr0 : trace,
 p tr0 -> forall tr1 : trace, bisim tr0 tr1 -> p tr1) ->
forall tr tr0 : trace,
followsT p tr tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> followsT p tr tr1
move => p hp.A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
forall tr tr0 : trace,
followsT p tr tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> followsT p tr tr1 cofix CIH.A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr tr0 : trace,
followsT p tr tr0 -> forall tr1 : trace, bisim tr0 tr1 -> followsT p tr tr1
forall tr tr0 : trace,
followsT p tr tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> followsT p tr tr1
move => tr tr0 h0 tr1 h1; invs h0.A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr tr0 : trace,
followsT p tr tr0 -> forall tr1 : trace, bisim tr0 tr1 -> followsT p tr tr1
tr0, tr1: trace
h1: bisim tr0 tr1
H0: p tr0
followsT p (Tnil (hd tr0)) tr1
A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr tr0 : trace,
followsT p tr tr0 -> forall tr1 : trace, bisim tr0 tr1 -> followsT p tr tr1
a: A
b: B
tr2, tr', tr1: trace
h1: bisim (Tcons a b tr') tr1
H: followsT p tr2 tr'
followsT p (Tcons a b tr2) tr1
-A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr tr0 : trace,
followsT p tr tr0 -> forall tr1 : trace, bisim tr0 tr1 -> followsT p tr tr1
tr0, tr1: trace
h1: bisim tr0 tr1
H0: p tr0
followsT p (Tnil (hd tr0)) tr1
A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr tr0 : trace,
followsT p tr tr0 -> forall tr1 : trace, bisim tr0 tr1 -> followsT p tr tr1
a: A
b: B
tr2, tr', tr1: trace
h1: bisim (Tcons a b tr') tr1
H: followsT p tr2 tr'
followsT p (Tcons a b tr2) tr1 apply: followsT_nil; first by symmetry; apply: (bisim_hd h1).A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr tr0 : trace,
followsT p tr tr0 -> forall tr1 : trace, bisim tr0 tr1 -> followsT p tr tr1
tr0, tr1: trace
h1: bisim tr0 tr1
H0: p tr0
p tr1
A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr tr0 : trace,
followsT p tr tr0 -> forall tr1 : trace, bisim tr0 tr1 -> followsT p tr tr1
a: A
b: B
tr2, tr', tr1: trace
h1: bisim (Tcons a b tr') tr1
H: followsT p tr2 tr'
followsT p (Tcons a b tr2) tr1
  exact: hp _ H0 _ h1.A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr tr0 : trace,
followsT p tr tr0 -> forall tr1 : trace, bisim tr0 tr1 -> followsT p tr tr1
a: A
b: B
tr2, tr', tr1: trace
h1: bisim (Tcons a b tr') tr1
H: followsT p tr2 tr'
followsT p (Tcons a b tr2) tr1
-A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr tr0 : trace,
followsT p tr tr0 -> forall tr1 : trace, bisim tr0 tr1 -> followsT p tr tr1
a: A
b: B
tr2, tr', tr1: trace
h1: bisim (Tcons a b tr') tr1
H: followsT p tr2 tr'
followsT p (Tcons a b tr2) tr1 invs h1.A, B: Type
p: trace -> Prop
hp: forall tr0 : trace,
p tr0 ->
forall tr1 : trace, bisim tr0 tr1 -> p tr1
CIH: forall tr tr0 : trace,
followsT p tr tr0 -> forall tr1 : trace, bisim tr0 tr1 -> followsT p tr tr1
a: A
b: B
tr2, tr', tr'0: trace
H: followsT p tr2 tr'
H4: bisim tr' tr'0
followsT p (Tcons a b tr2) (Tcons a b tr'0) exact: (followsT_delay a b (CIH _ _  H _ H4)).
Qed.

Lemma followsT_cont : forall (p q : trace -> Prop),
(forall tr, p tr -> q tr) ->
forall tr0 tr1, followsT p tr0 tr1 -> followsT q tr0 tr1.A, B: Type
forall p q : trace -> Prop,
(forall tr : trace, p tr -> q tr) ->
forall tr0 tr1 : trace,
followsT p tr0 tr1 -> followsT q tr0 tr1
Proof.A, B: Type
forall p q : trace -> Prop,
(forall tr : trace, p tr -> q tr) ->
forall tr0 tr1 : trace,
followsT p tr0 tr1 -> followsT q tr0 tr1
move => p q hpq.A, B: Type
p, q: trace -> Prop
hpq: forall tr : trace, p tr -> q tr
forall tr0 tr1 : trace,
followsT p tr0 tr1 -> followsT q tr0 tr1 cofix CIH.A, B: Type
p, q: trace -> Prop
hpq: forall tr : trace, p tr -> q tr
CIH: forall tr0 tr1 : trace, followsT p tr0 tr1 -> followsT q tr0 tr1
forall tr0 tr1 : trace,
followsT p tr0 tr1 -> followsT q tr0 tr1 move => tr0 tr1 h0; invs h0.A, B: Type
p, q: trace -> Prop
hpq: forall tr : trace, p tr -> q tr
CIH: forall tr0 tr1 : trace, followsT p tr0 tr1 -> followsT q tr0 tr1
tr1: trace
H0: p tr1
followsT q (Tnil (hd tr1)) tr1
A, B: Type
p, q: trace -> Prop
hpq: forall tr : trace, p tr -> q tr
CIH: forall tr0 tr1 : trace, followsT p tr0 tr1 -> followsT q tr0 tr1
a: A
b: B
tr, tr': trace
H: followsT p tr tr'
followsT q (Tcons a b tr) (Tcons a b tr')
-A, B: Type
p, q: trace -> Prop
hpq: forall tr : trace, p tr -> q tr
CIH: forall tr0 tr1 : trace, followsT p tr0 tr1 -> followsT q tr0 tr1
tr1: trace
H0: p tr1
followsT q (Tnil (hd tr1)) tr1
A, B: Type
p, q: trace -> Prop
hpq: forall tr : trace, p tr -> q tr
CIH: forall tr0 tr1 : trace, followsT p tr0 tr1 -> followsT q tr0 tr1
a: A
b: B
tr, tr': trace
H: followsT p tr tr'
followsT q (Tcons a b tr) (Tcons a b tr') apply: followsT_nil => //.A, B: Type
p, q: trace -> Prop
hpq: forall tr : trace, p tr -> q tr
CIH: forall tr0 tr1 : trace, followsT p tr0 tr1 -> followsT q tr0 tr1
tr1: trace
H0: p tr1
q tr1
A, B: Type
p, q: trace -> Prop
hpq: forall tr : trace, p tr -> q tr
CIH: forall tr0 tr1 : trace, followsT p tr0 tr1 -> followsT q tr0 tr1
a: A
b: B
tr, tr': trace
H: followsT p tr tr'
followsT q (Tcons a b tr) (Tcons a b tr')
  exact: hpq _ H0.A, B: Type
p, q: trace -> Prop
hpq: forall tr : trace, p tr -> q tr
CIH: forall tr0 tr1 : trace, followsT p tr0 tr1 -> followsT q tr0 tr1
a: A
b: B
tr, tr': trace
H: followsT p tr tr'
followsT q (Tcons a b tr) (Tcons a b tr')
-A, B: Type
p, q: trace -> Prop
hpq: forall tr : trace, p tr -> q tr
CIH: forall tr0 tr1 : trace, followsT p tr0 tr1 -> followsT q tr0 tr1
a: A
b: B
tr, tr': trace
H: followsT p tr tr'
followsT q (Tcons a b tr) (Tcons a b tr') exact/followsT_delay/CIH.
Qed.

Lemma followsT_singletonT : forall u tr0 tr1,
 followsT (singletonT u) tr0 tr1 -> bisim tr0 tr1.A, B: Type
forall (u : propA) (tr0 tr1 : trace),
followsT (singletonT u) tr0 tr1 -> bisim tr0 tr1
Proof.A, B: Type
forall (u : propA) (tr0 tr1 : trace),
followsT (singletonT u) tr0 tr1 -> bisim tr0 tr1
move => u.A, B: Type
u: propA
forall tr0 tr1 : trace,
followsT (singletonT u) tr0 tr1 -> bisim tr0 tr1 cofix CIH.A, B: Type
u: propA
CIH: forall tr0 tr1 : trace, followsT (singletonT u) tr0 tr1 -> bisim tr0 tr1
forall tr0 tr1 : trace,
followsT (singletonT u) tr0 tr1 -> bisim tr0 tr1 move => tr0 tr1 h0; invs h0.A, B: Type
u: propA
CIH: forall tr0 tr1 : trace, followsT (singletonT u) tr0 tr1 -> bisim tr0 tr1
tr1: trace
H0: singletonT u tr1
bisim (Tnil (hd tr1)) tr1
A, B: Type
u: propA
CIH: forall tr0 tr1 : trace, followsT (singletonT u) tr0 tr1 -> bisim tr0 tr1
a: A
b: B
tr, tr': trace
H: followsT (singletonT u) tr tr'
bisim (Tcons a b tr) (Tcons a b tr')
-A, B: Type
u: propA
CIH: forall tr0 tr1 : trace, followsT (singletonT u) tr0 tr1 -> bisim tr0 tr1
tr1: trace
H0: singletonT u tr1
bisim (Tnil (hd tr1)) tr1
A, B: Type
u: propA
CIH: forall tr0 tr1 : trace, followsT (singletonT u) tr0 tr1 -> bisim tr0 tr1
a: A
b: B
tr, tr': trace
H: followsT (singletonT u) tr tr'
bisim (Tcons a b tr) (Tcons a b tr') move: H0 => [a [h0 h1]]; invs h1 => /=.A, B: Type
u: propA
CIH: forall tr0 tr1 : trace, followsT (singletonT u) tr0 tr1 -> bisim tr0 tr1
a: A
h0: u a
bisim (Tnil a) (Tnil a)
A, B: Type
u: propA
CIH: forall tr0 tr1 : trace, followsT (singletonT u) tr0 tr1 -> bisim tr0 tr1
a: A
b: B
tr, tr': trace
H: followsT (singletonT u) tr tr'
bisim (Tcons a b tr) (Tcons a b tr')
  exact: bisim_refl.A, B: Type
u: propA
CIH: forall tr0 tr1 : trace, followsT (singletonT u) tr0 tr1 -> bisim tr0 tr1
a: A
b: B
tr, tr': trace
H: followsT (singletonT u) tr tr'
bisim (Tcons a b tr) (Tcons a b tr')
-A, B: Type
u: propA
CIH: forall tr0 tr1 : trace, followsT (singletonT u) tr0 tr1 -> bisim tr0 tr1
a: A
b: B
tr, tr': trace
H: followsT (singletonT u) tr tr'
bisim (Tcons a b tr) (Tcons a b tr') exact/bisim_cons/CIH.
Qed.

Lemma followsT_singleton_andA_L : forall u0 u1 tr0,
 followsT (singletonT (u0 andA u1)) tr0 tr0 ->
 followsT (singletonT u0) tr0 tr0.A, B: Type
forall (u0 u1 : propA) (tr0 : trace),
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
Proof.A, B: Type
forall (u0 u1 : propA) (tr0 : trace),
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
move => u0 u1.A, B: Type
u0, u1: propA
forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0 cofix CIH.A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0 case.A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
forall a : A,
followsT (singletonT (u0 andA u1)) (Tnil a) (Tnil a) ->
followsT (singletonT u0) (Tnil a) (Tnil a)
A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u0) (Tcons a b t) (Tcons a b t)
-A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
forall a : A,
followsT (singletonT (u0 andA u1)) (Tnil a) (Tnil a) ->
followsT (singletonT u0) (Tnil a) (Tnil a)
A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u0) (Tcons a b t) (Tcons a b t) move => a h0; inversion h0 => {H1 H}.A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
a: A
h0: followsT (singletonT (u0 andA u1)) (Tnil a)
  (Tnil a)
a0: A
tr: trace
H0: hd (Tnil a) = a
H2: tr = Tnil a
followsT (singletonT u0) (Tnil a) (Tnil a)
A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u0) (Tcons a b t) (Tcons a b t)
  move: H0 => /= H0; invs h0.A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
a, a0: A
H0: a = a
H1: hd (Tnil a) = a
H3: singletonT (u0 andA u1) (Tnil a)
followsT (singletonT u0) (Tnil a) (Tnil a)
A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u0) (Tcons a b t) (Tcons a b t)
  move: H3 => [a' [h1 h2]].A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
a, a0: A
H0: a = a
H1: hd (Tnil a) = a
a': A
h1: (u0 andA u1) a'
h2: bisim (Tnil a) (Tnil a')
followsT (singletonT u0) (Tnil a) (Tnil a)
A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u0) (Tcons a b t) (Tcons a b t) invs h2.A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
a0, a': A
H1: hd (Tnil a') = a'
H0: a' = a'
h1: (u0 andA u1) a'
followsT (singletonT u0) (Tnil a') (Tnil a')
A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u0) (Tcons a b t) (Tcons a b t) move: h1 => [h1 h2].A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
a0, a': A
H1: hd (Tnil a') = a'
H0: a' = a'
h1: u0 a'
h2: u1 a'
followsT (singletonT u0) (Tnil a') (Tnil a')
A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u0) (Tcons a b t) (Tcons a b t)
  apply: followsT_nil => //.A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
a0, a': A
H1: hd (Tnil a') = a'
H0: a' = a'
h1: u0 a'
h2: u1 a'
singletonT u0 (Tnil a')
A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u0) (Tcons a b t) (Tcons a b t)
  exact: nil_singletonT.A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u0) (Tcons a b t) (Tcons a b t)
-A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u0) (Tcons a b t) (Tcons a b t) move => a b tr0 h0; invs h0.A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u0) tr0 tr0
a: A
b: B
tr0: trace
H0: followsT (singletonT (u0 andA u1)) tr0 tr0
followsT (singletonT u0) (Tcons a b tr0)
  (Tcons a b tr0)
  exact/followsT_delay/CIH.
Qed.

Lemma followsT_singleton_andA_R : forall u0 u1 tr0,
 followsT (singletonT (u0 andA u1)) tr0 tr0 ->
 followsT (singletonT u1) tr0 tr0.A, B: Type
forall (u0 u1 : propA) (tr0 : trace),
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
Proof.A, B: Type
forall (u0 u1 : propA) (tr0 : trace),
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
move => u0 u1.A, B: Type
u0, u1: propA
forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0 cofix CIH.A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0 case.A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
forall a : A,
followsT (singletonT (u0 andA u1)) (Tnil a) (Tnil a) ->
followsT (singletonT u1) (Tnil a) (Tnil a)
A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u1) (Tcons a b t) (Tcons a b t)
-A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
forall a : A,
followsT (singletonT (u0 andA u1)) (Tnil a) (Tnil a) ->
followsT (singletonT u1) (Tnil a) (Tnil a)
A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u1) (Tcons a b t) (Tcons a b t) move => a h0; inversion h0 => {H1 H}.A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
a: A
h0: followsT (singletonT (u0 andA u1)) (Tnil a)
  (Tnil a)
a0: A
tr: trace
H0: hd (Tnil a) = a
H2: tr = Tnil a
followsT (singletonT u1) (Tnil a) (Tnil a)
A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u1) (Tcons a b t) (Tcons a b t)
  move: H0 => /= H0; invs h0.A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
a, a0: A
H0: a = a
H1: hd (Tnil a) = a
H3: singletonT (u0 andA u1) (Tnil a)
followsT (singletonT u1) (Tnil a) (Tnil a)
A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u1) (Tcons a b t) (Tcons a b t)
  move: H3 => [a' [h1 h2]].A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
a, a0: A
H0: a = a
H1: hd (Tnil a) = a
a': A
h1: (u0 andA u1) a'
h2: bisim (Tnil a) (Tnil a')
followsT (singletonT u1) (Tnil a) (Tnil a)
A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u1) (Tcons a b t) (Tcons a b t) invs h2.A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
a0, a': A
H1: hd (Tnil a') = a'
H0: a' = a'
h1: (u0 andA u1) a'
followsT (singletonT u1) (Tnil a') (Tnil a')
A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u1) (Tcons a b t) (Tcons a b t) move: h1 => [h1 h2].A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
a0, a': A
H1: hd (Tnil a') = a'
H0: a' = a'
h1: u0 a'
h2: u1 a'
followsT (singletonT u1) (Tnil a') (Tnil a')
A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u1) (Tcons a b t) (Tcons a b t)
  apply: followsT_nil => //.A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
a0, a': A
H1: hd (Tnil a') = a'
H0: a' = a'
h1: u0 a'
h2: u1 a'
singletonT u1 (Tnil a')
A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u1) (Tcons a b t) (Tcons a b t)
  exact: nil_singletonT.A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u1) (Tcons a b t) (Tcons a b t)
-A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
forall (a : A) (b : B) (t : trace),
followsT (singletonT (u0 andA u1)) (Tcons a b t)
  (Tcons a b t) ->
followsT (singletonT u1) (Tcons a b t) (Tcons a b t) move => a b tr0 h0; invs h0.A, B: Type
u0, u1: propA
CIH: forall tr0 : trace,
followsT (singletonT (u0 andA u1)) tr0 tr0 ->
followsT (singletonT u1) tr0 tr0
a: A
b: B
tr0: trace
H0: followsT (singletonT (u0 andA u1)) tr0 tr0
followsT (singletonT u1) (Tcons a b tr0)
  (Tcons a b tr0)
  exact/followsT_delay/CIH.
Qed.

Lemma singletonT_andA_followsT : forall u v tr,
 followsT (singletonT u) tr tr -> followsT (singletonT v) tr tr ->
 followsT (singletonT (u andA v)) tr tr.A, B: Type
forall (u v : propA) (tr : trace),
followsT (singletonT u) tr tr ->
followsT (singletonT v) tr tr ->
followsT (singletonT (u andA v)) tr tr
Proof.A, B: Type
forall (u v : propA) (tr : trace),
followsT (singletonT u) tr tr ->
followsT (singletonT v) tr tr ->
followsT (singletonT (u andA v)) tr tr
move => u v.A, B: Type
u, v: propA
forall tr : trace,
followsT (singletonT u) tr tr ->
followsT (singletonT v) tr tr ->
followsT (singletonT (u andA v)) tr tr cofix CIH.A, B: Type
u, v: propA
CIH: forall tr : trace,
followsT (singletonT u) tr tr ->
followsT (singletonT v) tr tr -> followsT (singletonT (u andA v)) tr tr
forall tr : trace,
followsT (singletonT u) tr tr ->
followsT (singletonT v) tr tr ->
followsT (singletonT (u andA v)) tr tr move => tr h0 h1; invs h0; invs h1.A, B: Type
u, v: propA
CIH: forall tr : trace,
followsT (singletonT u) tr tr ->
followsT (singletonT v) tr tr -> followsT (singletonT (u andA v)) tr tr
a: A
H: hd (Tnil a) = a
H0: singletonT u (Tnil a)
H2: hd (Tnil a) = a
H3: singletonT v (Tnil a)
followsT (singletonT (u andA v)) (Tnil a) (Tnil a)
A, B: Type
u, v: propA
CIH: forall tr : trace,
followsT (singletonT u) tr tr ->
followsT (singletonT v) tr tr -> followsT (singletonT (u andA v)) tr tr
a: A
b: B
tr0: trace
H1: followsT (singletonT u) tr0 tr0
H0: followsT (singletonT v) tr0 tr0
followsT (singletonT (u andA v)) (Tcons a b tr0)
  (Tcons a b tr0)
-A, B: Type
u, v: propA
CIH: forall tr : trace,
followsT (singletonT u) tr tr ->
followsT (singletonT v) tr tr -> followsT (singletonT (u andA v)) tr tr
a: A
H: hd (Tnil a) = a
H0: singletonT u (Tnil a)
H2: hd (Tnil a) = a
H3: singletonT v (Tnil a)
followsT (singletonT (u andA v)) (Tnil a) (Tnil a)
A, B: Type
u, v: propA
CIH: forall tr : trace,
followsT (singletonT u) tr tr ->
followsT (singletonT v) tr tr -> followsT (singletonT (u andA v)) tr tr
a: A
b: B
tr0: trace
H1: followsT (singletonT u) tr0 tr0
H0: followsT (singletonT v) tr0 tr0
followsT (singletonT (u andA v)) (Tcons a b tr0)
  (Tcons a b tr0) apply: followsT_nil => //.A, B: Type
u, v: propA
CIH: forall tr : trace,
followsT (singletonT u) tr tr ->
followsT (singletonT v) tr tr -> followsT (singletonT (u andA v)) tr tr
a: A
H: hd (Tnil a) = a
H0: singletonT u (Tnil a)
H2: hd (Tnil a) = a
H3: singletonT v (Tnil a)
singletonT (u andA v) (Tnil a)
A, B: Type
u, v: propA
CIH: forall tr : trace,
followsT (singletonT u) tr tr ->
followsT (singletonT v) tr tr -> followsT (singletonT (u andA v)) tr tr
a: A
b: B
tr0: trace
H1: followsT (singletonT u) tr0 tr0
H0: followsT (singletonT v) tr0 tr0
followsT (singletonT (u andA v)) (Tcons a b tr0)
  (Tcons a b tr0)
  apply: nil_singletonT.A, B: Type
u, v: propA
CIH: forall tr : trace,
followsT (singletonT u) tr tr ->
followsT (singletonT v) tr tr -> followsT (singletonT (u andA v)) tr tr
a: A
H: hd (Tnil a) = a
H0: singletonT u (Tnil a)
H2: hd (Tnil a) = a
H3: singletonT v (Tnil a)
(u andA v) a
A, B: Type
u, v: propA
CIH: forall tr : trace,
followsT (singletonT u) tr tr ->
followsT (singletonT v) tr tr -> followsT (singletonT (u andA v)) tr tr
a: A
b: B
tr0: trace
H1: followsT (singletonT u) tr0 tr0
H0: followsT (singletonT v) tr0 tr0
followsT (singletonT (u andA v)) (Tcons a b tr0)
  (Tcons a b tr0)
  by split; apply: singletonT_nil.A, B: Type
u, v: propA
CIH: forall tr : trace,
followsT (singletonT u) tr tr ->
followsT (singletonT v) tr tr -> followsT (singletonT (u andA v)) tr tr
a: A
b: B
tr0: trace
H1: followsT (singletonT u) tr0 tr0
H0: followsT (singletonT v) tr0 tr0
followsT (singletonT (u andA v)) (Tcons a b tr0)
  (Tcons a b tr0)
-A, B: Type
u, v: propA
CIH: forall tr : trace,
followsT (singletonT u) tr tr ->
followsT (singletonT v) tr tr -> followsT (singletonT (u andA v)) tr tr
a: A
b: B
tr0: trace
H1: followsT (singletonT u) tr0 tr0
H0: followsT (singletonT v) tr0 tr0
followsT (singletonT (u andA v)) (Tcons a b tr0)
  (Tcons a b tr0) exact/followsT_delay/CIH.
Qed.

Lemma followsT_ttA : forall tr, followsT (singletonT ttA) tr tr.A, B: Type
forall tr : trace, followsT (singletonT ttA) tr tr
Proof.A, B: Type
forall tr : trace, followsT (singletonT ttA) tr tr
cofix CIH.A, B: Type
CIH: forall tr : trace, followsT (singletonT ttA) tr tr
forall tr : trace, followsT (singletonT ttA) tr tr case => [a | a b tr0].A, B: Type
CIH: forall tr : trace, followsT (singletonT ttA) tr tr
a: A
followsT (singletonT ttA) (Tnil a) (Tnil a)
A, B: Type
CIH: forall tr : trace, followsT (singletonT ttA) tr tr
a: A
b: B
tr0: trace
followsT (singletonT ttA) (Tcons a b tr0)
  (Tcons a b tr0)
-A, B: Type
CIH: forall tr : trace, followsT (singletonT ttA) tr tr
a: A
followsT (singletonT ttA) (Tnil a) (Tnil a)
A, B: Type
CIH: forall tr : trace, followsT (singletonT ttA) tr tr
a: A
b: B
tr0: trace
followsT (singletonT ttA) (Tcons a b tr0)
  (Tcons a b tr0) apply: followsT_nil => //.A, B: Type
CIH: forall tr : trace, followsT (singletonT ttA) tr tr
a: A
singletonT ttA (Tnil a)
A, B: Type
CIH: forall tr : trace, followsT (singletonT ttA) tr tr
a: A
b: B
tr0: trace
followsT (singletonT ttA) (Tcons a b tr0)
  (Tcons a b tr0)
  exact: nil_singletonT.A, B: Type
CIH: forall tr : trace, followsT (singletonT ttA) tr tr
a: A
b: B
tr0: trace
followsT (singletonT ttA) (Tcons a b tr0)
  (Tcons a b tr0)
-A, B: Type
CIH: forall tr : trace, followsT (singletonT ttA) tr tr
a: A
b: B
tr0: trace
followsT (singletonT ttA) (Tcons a b tr0)
  (Tcons a b tr0) exact/followsT_delay/CIH.
Qed.

Append property

The append property holds for a trace whenever it has a prefix for which p1 holds, and p2 holds for the suffix.

Definition appendT (p1 p2 : trace -> Prop) : trace -> Prop :=
fun tr => exists tr', p1 tr' /\ followsT p2 tr' tr.

#[local] Infix "*+*" := appendT (at level 60, right associativity).

Lemma appendT_cont : forall (p0 p1 q0 q1 : trace -> Prop),
 (forall tr, p0 tr -> p1 tr) ->
 (forall tr, q0 tr -> q1 tr) ->
 forall tr, appendT p0 q0 tr -> appendT p1 q1 tr.A, B: Type
forall p0 p1 q0 q1 : trace -> Prop,
(forall tr : trace, p0 tr -> p1 tr) ->
(forall tr : trace, q0 tr -> q1 tr) ->
forall tr : trace, (p0 *+* q0) tr -> (p1 *+* q1) tr
Proof.A, B: Type
forall p0 p1 q0 q1 : trace -> Prop,
(forall tr : trace, p0 tr -> p1 tr) ->
(forall tr : trace, q0 tr -> q1 tr) ->
forall tr : trace, (p0 *+* q0) tr -> (p1 *+* q1) tr
move => p0 p1 q0 q1 hp hq tr [tr0 [h0 h1]].A, B: Type
p0, p1, q0, q1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
hq: forall tr : trace, q0 tr -> q1 tr
tr, tr0: trace
h0: p0 tr0
h1: followsT q0 tr0 tr
(p1 *+* q1) tr
exists tr0; split; first by apply: hp.A, B: Type
p0, p1, q0, q1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
hq: forall tr : trace, q0 tr -> q1 tr
tr, tr0: trace
h0: p0 tr0
h1: followsT q0 tr0 tr
followsT q1 tr0 tr
move: {h0} tr0 tr h1.A, B: Type
p0, p1, q0, q1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
hq: forall tr : trace, q0 tr -> q1 tr
forall tr0 tr : trace,
followsT q0 tr0 tr -> followsT q1 tr0 tr cofix CIH.A, B: Type
p0, p1, q0, q1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
hq: forall tr : trace, q0 tr -> q1 tr
CIH: forall tr0 tr : trace, followsT q0 tr0 tr -> followsT q1 tr0 tr
forall tr0 tr : trace,
followsT q0 tr0 tr -> followsT q1 tr0 tr
move => tr0 tr1 h0; invs h0.A, B: Type
p0, p1, q0, q1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
hq: forall tr : trace, q0 tr -> q1 tr
CIH: forall tr0 tr : trace, followsT q0 tr0 tr -> followsT q1 tr0 tr
tr1: trace
H0: q0 tr1
followsT q1 (Tnil (hd tr1)) tr1
A, B: Type
p0, p1, q0, q1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
hq: forall tr : trace, q0 tr -> q1 tr
CIH: forall tr0 tr : trace, followsT q0 tr0 tr -> followsT q1 tr0 tr
a: A
b: B
tr, tr': trace
H: followsT q0 tr tr'
followsT q1 (Tcons a b tr) (Tcons a b tr')
-A, B: Type
p0, p1, q0, q1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
hq: forall tr : trace, q0 tr -> q1 tr
CIH: forall tr0 tr : trace, followsT q0 tr0 tr -> followsT q1 tr0 tr
tr1: trace
H0: q0 tr1
followsT q1 (Tnil (hd tr1)) tr1
A, B: Type
p0, p1, q0, q1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
hq: forall tr : trace, q0 tr -> q1 tr
CIH: forall tr0 tr : trace, followsT q0 tr0 tr -> followsT q1 tr0 tr
a: A
b: B
tr, tr': trace
H: followsT q0 tr tr'
followsT q1 (Tcons a b tr) (Tcons a b tr') apply: followsT_nil => //.A, B: Type
p0, p1, q0, q1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
hq: forall tr : trace, q0 tr -> q1 tr
CIH: forall tr0 tr : trace, followsT q0 tr0 tr -> followsT q1 tr0 tr
tr1: trace
H0: q0 tr1
q1 tr1
A, B: Type
p0, p1, q0, q1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
hq: forall tr : trace, q0 tr -> q1 tr
CIH: forall tr0 tr : trace, followsT q0 tr0 tr -> followsT q1 tr0 tr
a: A
b: B
tr, tr': trace
H: followsT q0 tr tr'
followsT q1 (Tcons a b tr) (Tcons a b tr') exact: hq _ H0.A, B: Type
p0, p1, q0, q1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
hq: forall tr : trace, q0 tr -> q1 tr
CIH: forall tr0 tr : trace, followsT q0 tr0 tr -> followsT q1 tr0 tr
a: A
b: B
tr, tr': trace
H: followsT q0 tr tr'
followsT q1 (Tcons a b tr) (Tcons a b tr')
-A, B: Type
p0, p1, q0, q1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
hq: forall tr : trace, q0 tr -> q1 tr
CIH: forall tr0 tr : trace, followsT q0 tr0 tr -> followsT q1 tr0 tr
a: A
b: B
tr, tr': trace
H: followsT q0 tr tr'
followsT q1 (Tcons a b tr) (Tcons a b tr') exact/followsT_delay/CIH.
Qed.

Lemma appendT_cont_L : forall (p0 p1 q : trace -> Prop),
 (forall tr, p0 tr -> p1 tr) ->
 forall tr, (appendT p0 q tr) -> (appendT p1 q tr).A, B: Type
forall p0 p1 q : trace -> Prop,
(forall tr : trace, p0 tr -> p1 tr) ->
forall tr : trace, (p0 *+* q) tr -> (p1 *+* q) tr
Proof.A, B: Type
forall p0 p1 q : trace -> Prop,
(forall tr : trace, p0 tr -> p1 tr) ->
forall tr : trace, (p0 *+* q) tr -> (p1 *+* q) tr
move => p0 p1 q hp tr.A, B: Type
p0, p1, q: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
tr: trace
(p0 *+* q) tr -> (p1 *+* q) tr
exact: (@appendT_cont _ _ q q hp _).
Qed.

Lemma appendT_cont_R : forall (p q0 q1 : trace -> Prop),
(forall tr, q0 tr -> q1 tr) ->
forall tr, (appendT p q0 tr) -> (appendT p q1 tr).A, B: Type
forall p q0 q1 : trace -> Prop,
(forall tr : trace, q0 tr -> q1 tr) ->
forall tr : trace, (p *+* q0) tr -> (p *+* q1) tr
Proof.A, B: Type
forall p q0 q1 : trace -> Prop,
(forall tr : trace, q0 tr -> q1 tr) ->
forall tr : trace, (p *+* q0) tr -> (p *+* q1) tr
move => p q0 q1 hq tr.A, B: Type
p, q0, q1: trace -> Prop
hq: forall tr : trace, q0 tr -> q1 tr
tr: trace
(p *+* q0) tr -> (p *+* q1) tr
exact: (@appendT_cont p p _ _ _ hq).
Qed.

Lemma appendT_setoidT : forall (p0 p1 : trace -> Prop),
 setoidT p1 -> setoidT (appendT p0 p1).A, B: Type
forall p0 p1 : trace -> Prop,
setoidT p1 -> setoidT (p0 *+* p1)
Proof.A, B: Type
forall p0 p1 : trace -> Prop,
setoidT p1 -> setoidT (p0 *+* p1)
move => p0 p1 hp1 tr0 h0 tr1 h1.A, B: Type
p0, p1: trace -> Prop
hp1: setoidT p1
tr0: trace
h0: (p0 *+* p1) tr0
tr1: trace
h1: bisim tr0 tr1
(p0 *+* p1) tr1
move: h0 => [tr2 [h0 h2]].A, B: Type
p0, p1: trace -> Prop
hp1: setoidT p1
tr0, tr1: trace
h1: bisim tr0 tr1
tr2: trace
h0: p0 tr2
h2: followsT p1 tr2 tr0
(p0 *+* p1) tr1 exists tr2; split; first by apply: h0.A, B: Type
p0, p1: trace -> Prop
hp1: setoidT p1
tr0, tr1: trace
h1: bisim tr0 tr1
tr2: trace
h0: p0 tr2
h2: followsT p1 tr2 tr0
followsT p1 tr2 tr1
exact: (followsT_setoidT_R hp1 h2 h1).
Qed.

Lemma followsT_followsT : forall p q tr0 tr1 tr2, followsT p tr0 tr1 ->
 followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2.A, B: Type
forall (p q : trace -> Prop) (tr0 tr1 tr2 : trace),
followsT p tr0 tr1 ->
followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2
Proof.A, B: Type
forall (p q : trace -> Prop) (tr0 tr1 tr2 : trace),
followsT p tr0 tr1 ->
followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2
move => p q.A, B: Type
p, q: trace -> Prop
forall tr0 tr1 tr2 : trace,
followsT p tr0 tr1 ->
followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2 cofix CIH.A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 tr2 : trace,
followsT p tr0 tr1 -> followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2
forall tr0 tr1 tr2 : trace,
followsT p tr0 tr1 ->
followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2 case.A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 tr2 : trace,
followsT p tr0 tr1 -> followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2
forall (a : A) (tr1 tr2 : trace),
followsT p (Tnil a) tr1 ->
followsT q tr1 tr2 -> followsT (p *+* q) (Tnil a) tr2
A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 tr2 : trace,
followsT p tr0 tr1 -> followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2
forall (a : A) (b : B) (t tr1 tr2 : trace),
followsT p (Tcons a b t) tr1 ->
followsT q tr1 tr2 ->
followsT (p *+* q) (Tcons a b t) tr2
-A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 tr2 : trace,
followsT p tr0 tr1 -> followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2
forall (a : A) (tr1 tr2 : trace),
followsT p (Tnil a) tr1 ->
followsT q tr1 tr2 -> followsT (p *+* q) (Tnil a) tr2
A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 tr2 : trace,
followsT p tr0 tr1 -> followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2
forall (a : A) (b : B) (t tr1 tr2 : trace),
followsT p (Tcons a b t) tr1 ->
followsT q tr1 tr2 ->
followsT (p *+* q) (Tcons a b t) tr2 move => a tr1 tr2 h0 h1; invs h0.A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 tr2 : trace,
followsT p tr0 tr1 -> followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2
tr1, tr2: trace
h1: followsT q tr1 tr2
H1: p tr1
followsT (p *+* q) (Tnil (hd tr1)) tr2
A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 tr2 : trace,
followsT p tr0 tr1 -> followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2
forall (a : A) (b : B) (t tr1 tr2 : trace),
followsT p (Tcons a b t) tr1 ->
followsT q tr1 tr2 ->
followsT (p *+* q) (Tcons a b t) tr2 have := followsT_hd h1 => h2.A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 tr2 : trace,
followsT p tr0 tr1 -> followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2
tr1, tr2: trace
h1: followsT q tr1 tr2
H1: p tr1
h2: hd tr1 = hd tr2
followsT (p *+* q) (Tnil (hd tr1)) tr2
A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 tr2 : trace,
followsT p tr0 tr1 -> followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2
forall (a : A) (b : B) (t tr1 tr2 : trace),
followsT p (Tcons a b t) tr1 ->
followsT q tr1 tr2 ->
followsT (p *+* q) (Tcons a b t) tr2
  apply: followsT_nil => //.A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 tr2 : trace,
followsT p tr0 tr1 -> followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2
tr1, tr2: trace
h1: followsT q tr1 tr2
H1: p tr1
h2: hd tr1 = hd tr2
(p *+* q) tr2
A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 tr2 : trace,
followsT p tr0 tr1 -> followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2
forall (a : A) (b : B) (t tr1 tr2 : trace),
followsT p (Tcons a b t) tr1 ->
followsT q tr1 tr2 ->
followsT (p *+* q) (Tcons a b t) tr2 by exists tr1.A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 tr2 : trace,
followsT p tr0 tr1 -> followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2
forall (a : A) (b : B) (t tr1 tr2 : trace),
followsT p (Tcons a b t) tr1 ->
followsT q tr1 tr2 ->
followsT (p *+* q) (Tcons a b t) tr2
-A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 tr2 : trace,
followsT p tr0 tr1 -> followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2
forall (a : A) (b : B) (t tr1 tr2 : trace),
followsT p (Tcons a b t) tr1 ->
followsT q tr1 tr2 ->
followsT (p *+* q) (Tcons a b t) tr2 move => a b tr0 tr1 tr2 h0 h1; invs h0; invs h1.A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 tr2 : trace,
followsT p tr0 tr1 -> followsT q tr1 tr2 -> followsT (p *+* q) tr0 tr2
a: A
b: B
tr0, tr', tr'0: trace
H3: followsT p tr0 tr'
H4: followsT q tr' tr'0
followsT (p *+* q) (Tcons a b tr0) (Tcons a b tr'0)
  exact: followsT_delay _ _ (CIH _ _ _ H3 H4).
Qed.

Lemma appendT_assoc_L : forall p1 p2 p3 tr,
 (appendT (appendT p1 p2) p3) tr -> appendT p1 (appendT p2 p3) tr.A, B: Type
forall (p1 p2 p3 : trace -> Prop) (tr : trace),
((p1 *+* p2) *+* p3) tr -> (p1 *+* p2 *+* p3) tr
Proof.A, B: Type
forall (p1 p2 p3 : trace -> Prop) (tr : trace),
((p1 *+* p2) *+* p3) tr -> (p1 *+* p2 *+* p3) tr
move => p1 p2 p3 tr0 h1.A, B: Type
p1, p2, p3: trace -> Prop
tr0: trace
h1: ((p1 *+* p2) *+* p3) tr0
(p1 *+* p2 *+* p3) tr0 move: h1 => [tr1 [h1 h2]].A, B: Type
p1, p2, p3: trace -> Prop
tr0, tr1: trace
h1: (p1 *+* p2) tr1
h2: followsT p3 tr1 tr0
(p1 *+* p2 *+* p3) tr0 move: h1 => [tr2 h1].A, B: Type
p1, p2, p3: trace -> Prop
tr0, tr1: trace
h2: followsT p3 tr1 tr0
tr2: trace
h1: p1 tr2 /\ followsT p2 tr2 tr1
(p1 *+* p2 *+* p3) tr0
move: h1 => [h1 h3].A, B: Type
p1, p2, p3: trace -> Prop
tr0, tr1: trace
h2: followsT p3 tr1 tr0
tr2: trace
h1: p1 tr2
h3: followsT p2 tr2 tr1
(p1 *+* p2 *+* p3) tr0 exists tr2; split => {h1} //.A, B: Type
p1, p2, p3: trace -> Prop
tr0, tr1: trace
h2: followsT p3 tr1 tr0
tr2: trace
h3: followsT p2 tr2 tr1
followsT (p2 *+* p3) tr2 tr0
move: tr2 tr0 tr1 h2 h3.A, B: Type
p1, p2, p3: trace -> Prop
forall tr2 tr0 tr1 : trace,
followsT p3 tr1 tr0 ->
followsT p2 tr2 tr1 -> followsT (p2 *+* p3) tr2 tr0 cofix CIH.A, B: Type
p1, p2, p3: trace -> Prop
CIH: forall tr2 tr0 tr1 : trace,
followsT p3 tr1 tr0 -> followsT p2 tr2 tr1 -> followsT (p2 *+* p3) tr2 tr0
forall tr2 tr0 tr1 : trace,
followsT p3 tr1 tr0 ->
followsT p2 tr2 tr1 -> followsT (p2 *+* p3) tr2 tr0
move => tr0 tr1 tr2 h1 h2; invs h2.A, B: Type
p1, p2, p3: trace -> Prop
CIH: forall tr2 tr0 tr1 : trace,
followsT p3 tr1 tr0 -> followsT p2 tr2 tr1 -> followsT (p2 *+* p3) tr2 tr0
tr1, tr2: trace
h1: followsT p3 tr2 tr1
H0: p2 tr2
followsT (p2 *+* p3) (Tnil (hd tr2)) tr1
A, B: Type
p1, p2, p3: trace -> Prop
CIH: forall tr2 tr0 tr1 : trace,
followsT p3 tr1 tr0 -> followsT p2 tr2 tr1 -> followsT (p2 *+* p3) tr2 tr0
tr1: trace
a: A
b: B
tr': trace
h1: followsT p3 (Tcons a b tr') tr1
tr: trace
H: followsT p2 tr tr'
followsT (p2 *+* p3) (Tcons a b tr) tr1
-A, B: Type
p1, p2, p3: trace -> Prop
CIH: forall tr2 tr0 tr1 : trace,
followsT p3 tr1 tr0 -> followsT p2 tr2 tr1 -> followsT (p2 *+* p3) tr2 tr0
tr1, tr2: trace
h1: followsT p3 tr2 tr1
H0: p2 tr2
followsT (p2 *+* p3) (Tnil (hd tr2)) tr1
A, B: Type
p1, p2, p3: trace -> Prop
CIH: forall tr2 tr0 tr1 : trace,
followsT p3 tr1 tr0 -> followsT p2 tr2 tr1 -> followsT (p2 *+* p3) tr2 tr0
tr1: trace
a: A
b: B
tr': trace
h1: followsT p3 (Tcons a b tr') tr1
tr: trace
H: followsT p2 tr tr'
followsT (p2 *+* p3) (Tcons a b tr) tr1 apply: followsT_nil; last by exists tr2.A, B: Type
p1, p2, p3: trace -> Prop
CIH: forall tr2 tr0 tr1 : trace,
followsT p3 tr1 tr0 -> followsT p2 tr2 tr1 -> followsT (p2 *+* p3) tr2 tr0
tr1, tr2: trace
h1: followsT p3 tr2 tr1
H0: p2 tr2
hd tr1 = hd tr2
A, B: Type
p1, p2, p3: trace -> Prop
CIH: forall tr2 tr0 tr1 : trace,
followsT p3 tr1 tr0 -> followsT p2 tr2 tr1 -> followsT (p2 *+* p3) tr2 tr0
tr1: trace
a: A
b: B
tr': trace
h1: followsT p3 (Tcons a b tr') tr1
tr: trace
H: followsT p2 tr tr'
followsT (p2 *+* p3) (Tcons a b tr) tr1
  symmetry.A, B: Type
p1, p2, p3: trace -> Prop
CIH: forall tr2 tr0 tr1 : trace,
followsT p3 tr1 tr0 -> followsT p2 tr2 tr1 -> followsT (p2 *+* p3) tr2 tr0
tr1, tr2: trace
h1: followsT p3 tr2 tr1
H0: p2 tr2
hd tr2 = hd tr1
A, B: Type
p1, p2, p3: trace -> Prop
CIH: forall tr2 tr0 tr1 : trace,
followsT p3 tr1 tr0 -> followsT p2 tr2 tr1 -> followsT (p2 *+* p3) tr2 tr0
tr1: trace
a: A
b: B
tr': trace
h1: followsT p3 (Tcons a b tr') tr1
tr: trace
H: followsT p2 tr tr'
followsT (p2 *+* p3) (Tcons a b tr) tr1 exact: followsT_hd h1.A, B: Type
p1, p2, p3: trace -> Prop
CIH: forall tr2 tr0 tr1 : trace,
followsT p3 tr1 tr0 -> followsT p2 tr2 tr1 -> followsT (p2 *+* p3) tr2 tr0
tr1: trace
a: A
b: B
tr': trace
h1: followsT p3 (Tcons a b tr') tr1
tr: trace
H: followsT p2 tr tr'
followsT (p2 *+* p3) (Tcons a b tr) tr1
-A, B: Type
p1, p2, p3: trace -> Prop
CIH: forall tr2 tr0 tr1 : trace,
followsT p3 tr1 tr0 -> followsT p2 tr2 tr1 -> followsT (p2 *+* p3) tr2 tr0
tr1: trace
a: A
b: B
tr': trace
h1: followsT p3 (Tcons a b tr') tr1
tr: trace
H: followsT p2 tr tr'
followsT (p2 *+* p3) (Tcons a b tr) tr1 invs h1.A, B: Type
p1, p2, p3: trace -> Prop
CIH: forall tr2 tr0 tr1 : trace,
followsT p3 tr1 tr0 -> followsT p2 tr2 tr1 -> followsT (p2 *+* p3) tr2 tr0
a: A
b: B
tr', tr'0, tr: trace
H: followsT p2 tr tr'
H4: followsT p3 tr' tr'0
followsT (p2 *+* p3) (Tcons a b tr) (Tcons a b tr'0) exact: followsT_delay _ _ (CIH _ _ _ H4 H).
Qed.

Lemma appendT_finalTA : forall (p q : trace -> Prop) tr0 tr1,
 p tr0 -> q tr1 -> finalTA tr0 (hd tr1) ->
 (p *+* q) (tr0 +++ tr1).A, B: Type
forall (p q : trace -> Prop) (tr0 tr1 : trace),
p tr0 ->
q tr1 ->
finalTA tr0 (hd tr1) -> (p *+* q) (tr0 +++ tr1)
Proof.A, B: Type
forall (p q : trace -> Prop) (tr0 tr1 : trace),
p tr0 ->
q tr1 ->
finalTA tr0 (hd tr1) -> (p *+* q) (tr0 +++ tr1)
move => p q tr0 tr1 hp hq hfin.A, B: Type
p, q: trace -> Prop
tr0, tr1: trace
hp: p tr0
hq: q tr1
hfin: finalTA tr0 (hd tr1)
(p *+* q) (tr0 +++ tr1) exists tr0.A, B: Type
p, q: trace -> Prop
tr0, tr1: trace
hp: p tr0
hq: q tr1
hfin: finalTA tr0 (hd tr1)
p tr0 /\ followsT q tr0 (tr0 +++ tr1) split => //.A, B: Type
p, q: trace -> Prop
tr0, tr1: trace
hp: p tr0
hq: q tr1
hfin: finalTA tr0 (hd tr1)
followsT q tr0 (tr0 +++ tr1)
move: {hp} tr0 tr1 hq hfin.A, B: Type
p, q: trace -> Prop
forall tr0 tr1 : trace,
q tr1 ->
finalTA tr0 (hd tr1) -> followsT q tr0 (tr0 +++ tr1) cofix CIH.A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 : trace,
q tr1 -> finalTA tr0 (hd tr1) -> followsT q tr0 (tr0 +++ tr1)
forall tr0 tr1 : trace,
q tr1 ->
finalTA tr0 (hd tr1) -> followsT q tr0 (tr0 +++ tr1) case.A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 : trace,
q tr1 -> finalTA tr0 (hd tr1) -> followsT q tr0 (tr0 +++ tr1)
forall (a : A) (tr1 : trace),
q tr1 ->
finalTA (Tnil a) (hd tr1) ->
followsT q (Tnil a) (Tnil a +++ tr1)
A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 : trace,
q tr1 -> finalTA tr0 (hd tr1) -> followsT q tr0 (tr0 +++ tr1)
forall (a : A) (b : B) (t tr1 : trace),
q tr1 ->
finalTA (Tcons a b t) (hd tr1) ->
followsT q (Tcons a b t) (Tcons a b t +++ tr1)
-A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 : trace,
q tr1 -> finalTA tr0 (hd tr1) -> followsT q tr0 (tr0 +++ tr1)
forall (a : A) (tr1 : trace),
q tr1 ->
finalTA (Tnil a) (hd tr1) ->
followsT q (Tnil a) (Tnil a +++ tr1)
A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 : trace,
q tr1 -> finalTA tr0 (hd tr1) -> followsT q tr0 (tr0 +++ tr1)
forall (a : A) (b : B) (t tr1 : trace),
q tr1 ->
finalTA (Tcons a b t) (hd tr1) ->
followsT q (Tcons a b t) (Tcons a b t +++ tr1) move => a tr0 hq h1.A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 : trace,
q tr1 -> finalTA tr0 (hd tr1) -> followsT q tr0 (tr0 +++ tr1)
a: A
tr0: trace
hq: q tr0
h1: finalTA (Tnil a) (hd tr0)
followsT q (Tnil a) (Tnil a +++ tr0)
A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 : trace,
q tr1 -> finalTA tr0 (hd tr1) -> followsT q tr0 (tr0 +++ tr1)
forall (a : A) (b : B) (t tr1 : trace),
q tr1 ->
finalTA (Tcons a b t) (hd tr1) ->
followsT q (Tcons a b t) (Tcons a b t +++ tr1) rewrite trace_append_nil.A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 : trace,
q tr1 -> finalTA tr0 (hd tr1) -> followsT q tr0 (tr0 +++ tr1)
a: A
tr0: trace
hq: q tr0
h1: finalTA (Tnil a) (hd tr0)
followsT q (Tnil a) tr0
A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 : trace,
q tr1 -> finalTA tr0 (hd tr1) -> followsT q tr0 (tr0 +++ tr1)
forall (a : A) (b : B) (t tr1 : trace),
q tr1 ->
finalTA (Tcons a b t) (hd tr1) ->
followsT q (Tcons a b t) (Tcons a b t +++ tr1) invs h1.A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 : trace,
q tr1 -> finalTA tr0 (hd tr1) -> followsT q tr0 (tr0 +++ tr1)
tr0: trace
hq: q tr0
followsT q (Tnil (hd tr0)) tr0
A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 : trace,
q tr1 -> finalTA tr0 (hd tr1) -> followsT q tr0 (tr0 +++ tr1)
forall (a : A) (b : B) (t tr1 : trace),
q tr1 ->
finalTA (Tcons a b t) (hd tr1) ->
followsT q (Tcons a b t) (Tcons a b t +++ tr1)
  exact: followsT_nil.A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 : trace,
q tr1 -> finalTA tr0 (hd tr1) -> followsT q tr0 (tr0 +++ tr1)
forall (a : A) (b : B) (t tr1 : trace),
q tr1 ->
finalTA (Tcons a b t) (hd tr1) ->
followsT q (Tcons a b t) (Tcons a b t +++ tr1)
-A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 : trace,
q tr1 -> finalTA tr0 (hd tr1) -> followsT q tr0 (tr0 +++ tr1)
forall (a : A) (b : B) (t tr1 : trace),
q tr1 ->
finalTA (Tcons a b t) (hd tr1) ->
followsT q (Tcons a b t) (Tcons a b t +++ tr1) move => a b tr0 tr1 h0 h1; invs h1.A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 : trace,
q tr1 -> finalTA tr0 (hd tr1) -> followsT q tr0 (tr0 +++ tr1)
a: A
b: B
tr0, tr1: trace
h0: q tr1
H3: finalTA tr0 (hd tr1)
followsT q (Tcons a b tr0) (Tcons a b tr0 +++ tr1)
  rewrite [Tcons a b tr0 +++ tr1]trace_destr /=.A, B: Type
p, q: trace -> Prop
CIH: forall tr0 tr1 : trace,
q tr1 -> finalTA tr0 (hd tr1) -> followsT q tr0 (tr0 +++ tr1)
a: A
b: B
tr0, tr1: trace
h0: q tr1
H3: finalTA tr0 (hd tr1)
followsT q (Tcons a b tr0)
  (Tcons a b
     ((cofix trace_append (tr tr' : trace) : trace :=
         match tr with
         | Tnil _ => tr'
         | Tcons a b tr0 =>
             Tcons a b (trace_append tr0 tr')
         end) tr0 tr1))
  exact/followsT_delay/CIH.
Qed.

Definition AppendT (p1 p2 : propT) : propT :=
let: exist f0 h0 := p1 in
let: exist f1 h1 := p2 in
exist _ (appendT f0 f1) (appendT_setoidT h1).

#[local] Infix "***" := AppendT (at level 60, right associativity).

Lemma AppendT_assoc_L : forall p1 p2 p3, ((p1 *** p2) *** p3) =>> (p1 *** p2 *** p3).A, B: Type
forall p1 p2 p3 : propT,
((p1 *** p2) *** p3) =>> p1 *** p2 *** p3
Proof.A, B: Type
forall p1 p2 p3 : propT,
((p1 *** p2) *** p3) =>> p1 *** p2 *** p3
move => [f1 hf1] [f2 hf2] [f3 hf3] tr0 /= h1.A, B: Type
f1: trace -> Prop
hf1: setoidT f1
f2: trace -> Prop
hf2: setoidT f2
f3: trace -> Prop
hf3: setoidT f3
tr0: trace
h1: ((f1 *+* f2) *+* f3) tr0
(f1 *+* f2 *+* f3) tr0
exact: appendT_assoc_L.
Qed.

Lemma AppendT_cont : forall p1 p2 q1 q2, p1 =>> p2 -> q1 =>> q2 -> (p1 *** q1) =>> (p2 *** q2).A, B: Type
forall p1 p2 q1 q2 : propT,
p1 =>> p2 -> q1 =>> q2 -> (p1 *** q1) =>> p2 *** q2
Proof.A, B: Type
forall p1 p2 q1 q2 : propT,
p1 =>> p2 -> q1 =>> q2 -> (p1 *** q1) =>> p2 *** q2
move => [p1 hp1] [p2 hp2] [q1 hq1] [q2 hq2] h0 h1 tr0 /= h2.A, B: Type
p1: trace -> Prop
hp1: setoidT p1
p2: trace -> Prop
hp2: setoidT p2
q1: trace -> Prop
hq1: setoidT q1
q2: trace -> Prop
hq2: setoidT q2
h0: exist (fun p : trace -> Prop => setoidT p) p1 hp1 =>>
exist (fun p : trace -> Prop => setoidT p) p2 hp2
h1: exist (fun p : trace -> Prop => setoidT p) q1 hq1 =>>
exist (fun p : trace -> Prop => setoidT p) q2 hq2
tr0: trace
h2: (p1 *+* q1) tr0
(p2 *+* q2) tr0
apply: (appendT_cont _ _ h2).A, B: Type
p1: trace -> Prop
hp1: setoidT p1
p2: trace -> Prop
hp2: setoidT p2
q1: trace -> Prop
hq1: setoidT q1
q2: trace -> Prop
hq2: setoidT q2
h0: exist (fun p : trace -> Prop => setoidT p) p1 hp1 =>>
exist (fun p : trace -> Prop => setoidT p) p2 hp2
h1: exist (fun p : trace -> Prop => setoidT p) q1 hq1 =>>
exist (fun p : trace -> Prop => setoidT p) q2 hq2
tr0: trace
h2: (p1 *+* q1) tr0
forall tr : trace, p1 tr -> p2 tr
A, B: Type
p1: trace -> Prop
hp1: setoidT p1
p2: trace -> Prop
hp2: setoidT p2
q1: trace -> Prop
hq1: setoidT q1
q2: trace -> Prop
hq2: setoidT q2
h0: exist (fun p : trace -> Prop => setoidT p) p1 hp1 =>>
exist (fun p : trace -> Prop => setoidT p) p2 hp2
h1: exist (fun p : trace -> Prop => setoidT p) q1 hq1 =>>
exist (fun p : trace -> Prop => setoidT p) q2 hq2
tr0: trace
h2: (p1 *+* q1) tr0
forall tr : trace, q1 tr -> q2 tr
-A, B: Type
p1: trace -> Prop
hp1: setoidT p1
p2: trace -> Prop
hp2: setoidT p2
q1: trace -> Prop
hq1: setoidT q1
q2: trace -> Prop
hq2: setoidT q2
h0: exist (fun p : trace -> Prop => setoidT p) p1 hp1 =>>
exist (fun p : trace -> Prop => setoidT p) p2 hp2
h1: exist (fun p : trace -> Prop => setoidT p) q1 hq1 =>>
exist (fun p : trace -> Prop => setoidT p) q2 hq2
tr0: trace
h2: (p1 *+* q1) tr0
forall tr : trace, p1 tr -> p2 tr
A, B: Type
p1: trace -> Prop
hp1: setoidT p1
p2: trace -> Prop
hp2: setoidT p2
q1: trace -> Prop
hq1: setoidT q1
q2: trace -> Prop
hq2: setoidT q2
h0: exist (fun p : trace -> Prop => setoidT p) p1 hp1 =>>
exist (fun p : trace -> Prop => setoidT p) p2 hp2
h1: exist (fun p : trace -> Prop => setoidT p) q1 hq1 =>>
exist (fun p : trace -> Prop => setoidT p) q2 hq2
tr0: trace
h2: (p1 *+* q1) tr0
forall tr : trace, q1 tr -> q2 tr exact: h0.A, B: Type
p1: trace -> Prop
hp1: setoidT p1
p2: trace -> Prop
hp2: setoidT p2
q1: trace -> Prop
hq1: setoidT q1
q2: trace -> Prop
hq2: setoidT q2
h0: exist (fun p : trace -> Prop => setoidT p) p1 hp1 =>>
exist (fun p : trace -> Prop => setoidT p) p2 hp2
h1: exist (fun p : trace -> Prop => setoidT p) q1 hq1 =>>
exist (fun p : trace -> Prop => setoidT p) q2 hq2
tr0: trace
h2: (p1 *+* q1) tr0
forall tr : trace, q1 tr -> q2 tr
-A, B: Type
p1: trace -> Prop
hp1: setoidT p1
p2: trace -> Prop
hp2: setoidT p2
q1: trace -> Prop
hq1: setoidT q1
q2: trace -> Prop
hq2: setoidT q2
h0: exist (fun p : trace -> Prop => setoidT p) p1 hp1 =>>
exist (fun p : trace -> Prop => setoidT p) p2 hp2
h1: exist (fun p : trace -> Prop => setoidT p) q1 hq1 =>>
exist (fun p : trace -> Prop => setoidT p) q2 hq2
tr0: trace
h2: (p1 *+* q1) tr0
forall tr : trace, q1 tr -> q2 tr exact: h1.
Qed.

Lemma AppendT_cont_L : forall p1 p2 q, p1 =>> p2 -> (p1 *** q) =>> (p2 *** q).A, B: Type
forall p1 p2 q : propT,
p1 =>> p2 -> (p1 *** q) =>> p2 *** q
Proof.A, B: Type
forall p1 p2 q : propT,
p1 =>> p2 -> (p1 *** q) =>> p2 *** q
move => [p1 hp1] [p2 hp2] [q hq] h0 tr0 /=.A, B: Type
p1: trace -> Prop
hp1: setoidT p1
p2: trace -> Prop
hp2: setoidT p2
q: trace -> Prop
hq: setoidT q
h0: exist (fun p : trace -> Prop => setoidT p) p1 hp1 =>>
exist (fun p : trace -> Prop => setoidT p) p2 hp2
tr0: trace
(p1 *+* q) tr0 -> (p2 *+* q) tr0
exact: appendT_cont_L.
Qed.

Lemma AppendT_cont_R : forall q p1 p2, p1 =>> p2 -> (q *** p1) =>> (q *** p2).A, B: Type
forall q p1 p2 : propT,
p1 =>> p2 -> (q *** p1) =>> q *** p2
Proof.A, B: Type
forall q p1 p2 : propT,
p1 =>> p2 -> (q *** p1) =>> q *** p2
move => [q hq] [p1 hp1] [p2 hp2] h0 tr0 /= h1.A, B: Type
q: trace -> Prop
hq: setoidT q
p1: trace -> Prop
hp1: setoidT p1
p2: trace -> Prop
hp2: setoidT p2
h0: exist (fun p : trace -> Prop => setoidT p) p1 hp1 =>>
exist (fun p : trace -> Prop => setoidT p) p2 hp2
tr0: trace
h1: (q *+* p1) tr0
(q *+* p2) tr0
exact: (@appendT_cont q q p1 p2).
Qed.

Lemma AppendT_ttA : forall p, p =>> (p *** [|ttA|]).A, B: Type
forall p : propT, p =>> p *** ([|ttA|])
Proof.A, B: Type
forall p : propT, p =>> p *** ([|ttA|])
move => [f hp] tr0 /= h0.A, B: Type
f: trace -> Prop
hp: setoidT f
tr0: trace
h0: f tr0
(f *+* singletonT ttA) tr0
exists tr0; split => //.A, B: Type
f: trace -> Prop
hp: setoidT f
tr0: trace
h0: f tr0
followsT (singletonT ttA) tr0 tr0
move: {h0 hp} tr0.A, B: Type
f: trace -> Prop
forall tr0 : trace, followsT (singletonT ttA) tr0 tr0 cofix CIH.A, B: Type
f: trace -> Prop
CIH: forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
case => [a | a b tr0].A, B: Type
f: trace -> Prop
CIH: forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
a: A
followsT (singletonT ttA) (Tnil a) (Tnil a)
A, B: Type
f: trace -> Prop
CIH: forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
a: A
b: B
tr0: trace
followsT (singletonT ttA) (Tcons a b tr0)
  (Tcons a b tr0)
-A, B: Type
f: trace -> Prop
CIH: forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
a: A
followsT (singletonT ttA) (Tnil a) (Tnil a)
A, B: Type
f: trace -> Prop
CIH: forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
a: A
b: B
tr0: trace
followsT (singletonT ttA) (Tcons a b tr0)
  (Tcons a b tr0) exact/followsT_nil/nil_singletonT.A, B: Type
f: trace -> Prop
CIH: forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
a: A
b: B
tr0: trace
followsT (singletonT ttA) (Tcons a b tr0)
  (Tcons a b tr0)
-A, B: Type
f: trace -> Prop
CIH: forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
a: A
b: B
tr0: trace
followsT (singletonT ttA) (Tcons a b tr0)
  (Tcons a b tr0) exact/followsT_delay/CIH.
Qed.

Lemma SingletonT_DupT_AppendT_andA_DupT : forall u v b, ([|u|] *** <<v;b>>) =>> <<u andA v;b>>.A, B: Type
forall (u v : propA) (b : B),
(([|u|]) *** (<< v; b >>)) =>> (<< u andA v; b >>)
Proof.A, B: Type
forall (u v : propA) (b : B),
(([|u|]) *** (<< v; b >>)) =>> (<< u andA v; b >>)
move => u v b tr0 [tr1 [[a [h0 h2]] h1]] /=; invs h2; invs h1.A, B: Type
u, v: propA
b: B
tr0: trace
h0: u (hd tr0)
H1: dupT v b tr0
dupT (u andA v) b tr0
move: H1 => [a [h1 h2]]; invs h2; invs H1.A, B: Type
u, v: propA
b: B
a: A
h0: u (hd (Tcons a b (Tnil a)))
h1: v a
dupT (u andA v) b (Tcons a b (Tnil a))
exact: dupT_Tcons.
Qed.

Lemma DupT_andA_AppendT_SingletonT_DupT : forall u v b, <<u andA v;b>> =>> ([|u|] *** <<v;b>>).A, B: Type
forall (u v : propA) (b : B),
(<< u andA v; b >>) =>> ([|u|]) *** (<< v; b >>)
Proof.A, B: Type
forall (u v : propA) (b : B),
(<< u andA v; b >>) =>> ([|u|]) *** (<< v; b >>)
move => u v b tr0 [a [[hu hv] h1]]; invs h1; invs H1.A, B: Type
u, v: propA
b: B
a: A
hu: u a
hv: v a
satisfyT (([|u|]) *** (<< v; b >>))
  (Tcons a b (Tnil a))
exists (Tnil a); split; first by apply: nil_singletonT.A, B: Type
u, v: propA
b: B
a: A
hu: u a
hv: v a
followsT (dupT v b) (Tnil a) (Tcons a b (Tnil a))
apply: followsT_nil => //.A, B: Type
u, v: propA
b: B
a: A
hu: u a
hv: v a
dupT v b (Tcons a b (Tnil a))
exact: dupT_Tcons.
Qed.

Lemma DupT_andA_AppendT_SingletonT : forall u v b, <<u andA v;b>> =>> <<u;b>> *** [|v|].A, B: Type
forall (u v : propA) (b : B),
(<< u andA v; b >>) =>> (<< u; b >>) *** ([|v|])
Proof.A, B: Type
forall (u v : propA) (b : B),
(<< u andA v; b >>) =>> (<< u; b >>) *** ([|v|])
move => u v b tr0 [a [[hu hv] h0]]; invs h0; invs H1.A, B: Type
u, v: propA
b: B
a: A
hu: u a
hv: v a
satisfyT ((<< u; b >>) *** ([|v|]))
  (Tcons a b (Tnil a))
exists (Tcons a b (Tnil a)); split.A, B: Type
u, v: propA
b: B
a: A
hu: u a
hv: v a
dupT u b (Tcons a b (Tnil a))
A, B: Type
u, v: propA
b: B
a: A
hu: u a
hv: v a
followsT (singletonT v) (Tcons a b (Tnil a))
  (Tcons a b (Tnil a))
-A, B: Type
u, v: propA
b: B
a: A
hu: u a
hv: v a
dupT u b (Tcons a b (Tnil a))
A, B: Type
u, v: propA
b: B
a: A
hu: u a
hv: v a
followsT (singletonT v) (Tcons a b (Tnil a))
  (Tcons a b (Tnil a)) exact: dupT_Tcons.A, B: Type
u, v: propA
b: B
a: A
hu: u a
hv: v a
followsT (singletonT v) (Tcons a b (Tnil a))
  (Tcons a b (Tnil a))
-A, B: Type
u, v: propA
b: B
a: A
hu: u a
hv: v a
followsT (singletonT v) (Tcons a b (Tnil a))
  (Tcons a b (Tnil a)) apply: followsT_delay.A, B: Type
u, v: propA
b: B
a: A
hu: u a
hv: v a
followsT (singletonT v) (Tnil a) (Tnil a) apply: followsT_nil => //.A, B: Type
u, v: propA
b: B
a: A
hu: u a
hv: v a
singletonT v (Tnil a)
  exact: nil_singletonT.
Qed.

Lemma DupT_AppendT_SingletonT_andA_DupT : forall u v b, (<<u;b>> *** [|v|]) =>> <<u andA v;b>>.A, B: Type
forall (u v : propA) (b : B),
((<< u; b >>) *** ([|v|])) =>> (<< u andA v; b >>)
Proof.A, B: Type
forall (u v : propA) (b : B),
((<< u; b >>) *** ([|v|])) =>> (<< u andA v; b >>)
move => u v b tr0 [tr1 [[a [hu h0]] h1]].A, B: Type
u, v: propA
b: B
tr0, tr1: trace
a: A
hu: u a
h0: bisim tr1 (Tcons a b (Tnil a))
h1: followsT (singletonT v) tr1 tr0
satisfyT (<< u andA v; b >>) tr0
invs h0; invs H1; invs h1; invs H3; move: H1 => [a [hv h0]]; invs h0 => /=.A, B: Type
u, v: propA
b: B
a: A
hu: u (hd (Tnil a))
hv: v a
dupT (u andA v) b (Tcons a b (Tnil a))
exact: dupT_Tcons.
Qed.

Lemma AppendT_andA : forall u v, ([|u|] *** [|v|]) =>> [|u andA v|].A, B: Type
forall u v : propA,
(([|u|]) *** ([|v|])) =>> ([|u andA v|])
Proof.A, B: Type
forall u v : propA,
(([|u|]) *** ([|v|])) =>> ([|u andA v|])
move => u v tr0 [tr1 [[a [hu h0]] h1]].A, B: Type
u, v: propA
tr0, tr1: trace
a: A
hu: u a
h0: bisim tr1 (Tnil a)
h1: followsT (singletonT v) tr1 tr0
satisfyT ([|u andA v|]) tr0
invs h0; invs h1; move: H1 => [a [hv h0]]; invs h0 => /=.A, B: Type
u, v: propA
a: A
hu: u (hd (Tnil a))
hv: v a
singletonT (u andA v) (Tnil a)
exact: nil_singletonT.
Qed.

Lemma andA_AppendT : forall u v, [|u andA v|] =>> [|u|] *** [|v|].A, B: Type
forall u v : propA,
([|u andA v|]) =>> ([|u|]) *** ([|v|])
Proof.A, B: Type
forall u v : propA,
([|u andA v|]) =>> ([|u|]) *** ([|v|])
move => u v tr0 [a [[hu hv] h0]]; invs h0.A, B: Type
u, v: propA
a: A
hu: u a
hv: v a
satisfyT (([|u|]) *** ([|v|])) (Tnil a)
exists (Tnil a); split; first by apply: nil_singletonT.A, B: Type
u, v: propA
a: A
hu: u a
hv: v a
followsT (singletonT v) (Tnil a) (Tnil a)
apply: followsT_nil => //.A, B: Type
u, v: propA
a: A
hu: u a
hv: v a
singletonT v (Tnil a)
exact: nil_singletonT.
Qed.

Lemma SingletonT_AppendT : forall v p, ([|v|] *** p) =>> p.A, B: Type
forall (v : propA) (p : propT), (([|v|]) *** p) =>> p
Proof.A, B: Type
forall (v : propA) (p : propT), (([|v|]) *** p) =>> p
by move => v [p hp] tr0 /= [tr1 [[a [h0 h2]] h1]]; invs h1; invs h2.
Qed.

Lemma ttA_AppendT_implies : forall p, ([|ttA|] *** p) =>> p.A, B: Type
forall p : propT, (([|ttA|]) *** p) =>> p
Proof.A, B: Type
forall p : propT, (([|ttA|]) *** p) =>> p
move => p.A, B: Type
p: propT
(([|ttA|]) *** p) =>> p
exact: SingletonT_AppendT.
Qed.

Lemma implies_ttA_AppendT : forall p, p =>> [|ttA|] *** p.A, B: Type
forall p : propT, p =>> ([|ttA|]) *** p
Proof.A, B: Type
forall p : propT, p =>> ([|ttA|]) *** p
move => [p hp] tr0 /= htr0.A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
htr0: p tr0
(singletonT ttA *+* p) tr0
exists (Tnil (hd tr0)); split.A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
htr0: p tr0
singletonT ttA (Tnil (hd tr0))
A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
htr0: p tr0
followsT p (Tnil (hd tr0)) tr0
-A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
htr0: p tr0
singletonT ttA (Tnil (hd tr0))
A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
htr0: p tr0
followsT p (Tnil (hd tr0)) tr0 exact: nil_singletonT.A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
htr0: p tr0
followsT p (Tnil (hd tr0)) tr0
-A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
htr0: p tr0
followsT p (Tnil (hd tr0)) tr0 exact: followsT_nil.
Qed.

Lemma appendT_singletonT : forall p (hp : setoidT p) u tr,
 appendT p (singletonT u) tr -> p tr.A, B: Type
forall p : trace -> Prop,
setoidT p ->
forall (u : propA) (tr : trace),
(p *+* singletonT u) tr -> p tr
Proof.A, B: Type
forall p : trace -> Prop,
setoidT p ->
forall (u : propA) (tr : trace),
(p *+* singletonT u) tr -> p tr
move => p hp u tr0 [tr1 [h1 h2]].A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
tr0, tr1: trace
h1: p tr1
h2: followsT (singletonT u) tr1 tr0
p tr0
exact: (hp _ h1 _ (followsT_singletonT h2)).
Qed.

Lemma AppendT_Singleton : forall p v, (p *** [|v|]) =>> p.A, B: Type
forall (p : propT) (v : propA), (p *** ([|v|])) =>> p
Proof.A, B: Type
forall (p : propT) (v : propA), (p *** ([|v|])) =>> p
move => [p hp] v tr0 /=.A, B: Type
p: trace -> Prop
hp: setoidT p
v: propA
tr0: trace
(p *+* singletonT v) tr0 -> p tr0
exact: appendT_singletonT.
Qed.

Lemma AppendT_ttA_implies : forall p, (p *** [|ttA|]) =>> p.A, B: Type
forall p : propT, (p *** ([|ttA|])) =>> p
Proof.A, B: Type
forall p : propT, (p *** ([|ttA|])) =>> p
move => p.A, B: Type
p: propT
(p *** ([|ttA|])) =>> p
exact: AppendT_Singleton.
Qed.

Lemma implies_AppendT_ttA : forall p, p =>> p *** [|ttA|].A, B: Type
forall p : propT, p =>> p *** ([|ttA|])
Proof.A, B: Type
forall p : propT, p =>> p *** ([|ttA|])
move => [p hp] tr0 /= htr0.A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
htr0: p tr0
(p *+* singletonT ttA) tr0
exists tr0; split => //.A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
htr0: p tr0
followsT (singletonT ttA) tr0 tr0
move: {hp htr0} tr0.A, B: Type
p: trace -> Prop
forall tr0 : trace, followsT (singletonT ttA) tr0 tr0 cofix CIH.A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
case => [a | a b tr0].A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
a: A
followsT (singletonT ttA) (Tnil a) (Tnil a)
A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
a: A
b: B
tr0: trace
followsT (singletonT ttA) (Tcons a b tr0)
  (Tcons a b tr0)
-A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
a: A
followsT (singletonT ttA) (Tnil a) (Tnil a)
A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
a: A
b: B
tr0: trace
followsT (singletonT ttA) (Tcons a b tr0)
  (Tcons a b tr0) apply: followsT_nil => //.A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
a: A
singletonT ttA (Tnil a)
A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
a: A
b: B
tr0: trace
followsT (singletonT ttA) (Tcons a b tr0)
  (Tcons a b tr0)
  exact: nil_singletonT.A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
a: A
b: B
tr0: trace
followsT (singletonT ttA) (Tcons a b tr0)
  (Tcons a b tr0)
-A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (singletonT ttA) tr0 tr0
a: A
b: B
tr0: trace
followsT (singletonT ttA) (Tcons a b tr0)
  (Tcons a b tr0) exact/followsT_delay/CIH.
Qed.

Lemma TtT_AppendT_idem : (TtT *** TtT) =>> TtT.A, B: Type
(TtT *** TtT) =>> TtT
Proof.A, B: Type
(TtT *** TtT) =>> TtT by []. Qed.

Lemma AppendT_FiniteT_idem : (FiniteT *** FiniteT) =>> FiniteT.A, B: Type
(FiniteT *** FiniteT) =>> FiniteT
Proof.A, B: Type
(FiniteT *** FiniteT) =>> FiniteT
move => tr0 [tr1 [Hfin Hfol]].A, B: Type
tr0, tr1: trace
Hfin: finiteT tr1
Hfol: followsT (fun tr : trace => finiteT tr) tr1 tr0
satisfyT FiniteT tr0
elim: Hfin tr0 Hfol => [a tr0' | a b tr1' h0 IH tr0] Hfol; invs Hfol => //.A, B: Type
tr1: trace
a: A
b: B
tr1': trace
h0: finiteT tr1'
IH: forall tr0 : trace,
followsT (fun tr : trace => finiteT tr) tr1' tr0 ->
satisfyT FiniteT tr0
tr': trace
H3: followsT (fun tr : trace => finiteT tr) tr1' tr'
satisfyT FiniteT (Tcons a b tr')
exact/finiteT_delay/IH.
Qed.

Lemma FiniteT_AppendT_idem : FiniteT =>> FiniteT *** FiniteT.A, B: Type
FiniteT =>> FiniteT *** FiniteT
Proof.A, B: Type
FiniteT =>> FiniteT *** FiniteT
move => tr0 h0.A, B: Type
tr0: trace
h0: satisfyT FiniteT tr0
satisfyT (FiniteT *** FiniteT) tr0
exists (Tnil (hd tr0)); split.A, B: Type
tr0: trace
h0: satisfyT FiniteT tr0
finiteT (Tnil (hd tr0))
A, B: Type
tr0: trace
h0: satisfyT FiniteT tr0
followsT (fun tr : trace => finiteT tr)
  (Tnil (hd tr0)) tr0
-A, B: Type
tr0: trace
h0: satisfyT FiniteT tr0
finiteT (Tnil (hd tr0))
A, B: Type
tr0: trace
h0: satisfyT FiniteT tr0
followsT (fun tr : trace => finiteT tr)
  (Tnil (hd tr0)) tr0 exact: finiteT_nil.A, B: Type
tr0: trace
h0: satisfyT FiniteT tr0
followsT (fun tr : trace => finiteT tr)
  (Tnil (hd tr0)) tr0
-A, B: Type
tr0: trace
h0: satisfyT FiniteT tr0
followsT (fun tr : trace => finiteT tr)
  (Tnil (hd tr0)) tr0 exact: followsT_nil.
Qed.

Lemma FiniteT_SingletonT : forall u, (FiniteT *** [|u|]) =>> FiniteT.A, B: Type
forall u : propA, (FiniteT *** ([|u|])) =>> FiniteT
Proof.A, B: Type
forall u : propA, (FiniteT *** ([|u|])) =>> FiniteT
move => u tr /= [tr1 [h0 h1]].A, B: Type
u: propA
tr, tr1: trace
h0: finiteT tr1
h1: followsT (singletonT u) tr1 tr
finiteT tr
exact: (finiteT_setoidT h0 (followsT_singletonT h1)).
Qed.

Lemma InfiniteT_implies_AppendT : InfiniteT =>> (TtT *** [|ffA|]).A, B: Type
InfiniteT =>> TtT *** ([|ffA|])
Proof.A, B: Type
InfiniteT =>> TtT *** ([|ffA|])
move => tr0 [a b tr1] HinfT /=.A, B: Type
tr0: trace
a: A
b: B
tr1: trace
HinfT: infiniteT tr1
(ttT *+* singletonT ffA) (Tcons a b tr1)
exists (Tcons a b tr1); split => {tr0} //.A, B: Type
a: A
b: B
tr1: trace
HinfT: infiniteT tr1
followsT (singletonT ffA) (Tcons a b tr1)
  (Tcons a b tr1)
move: a b tr1 HinfT.A, B: Type
forall (a : A) (b : B) (tr1 : trace),
infiniteT tr1 ->
followsT (singletonT ffA) (Tcons a b tr1)
  (Tcons a b tr1) cofix CIH.A, B: Type
CIH: forall (a : A) (b : B) (tr1 : trace),
infiniteT tr1 -> followsT (singletonT ffA) (Tcons a b tr1) (Tcons a b tr1)
forall (a : A) (b : B) (tr1 : trace),
infiniteT tr1 ->
followsT (singletonT ffA) (Tcons a b tr1)
  (Tcons a b tr1)
move => a b tr1 HinfT; invs HinfT.A, B: Type
CIH: forall (a : A) (b : B) (tr1 : trace),
infiniteT tr1 -> followsT (singletonT ffA) (Tcons a b tr1) (Tcons a b tr1)
a: A
b: B
a0: A
b0: B
tr: trace
H: infiniteT tr
followsT (singletonT ffA) (Tcons a b (Tcons a0 b0 tr))
  (Tcons a b (Tcons a0 b0 tr))
exact/followsT_delay/CIH.
Qed.

Lemma AppendT_implies_InfiniteT : (TtT *** [|ffA|]) =>> InfiniteT.A, B: Type
(TtT *** ([|ffA|])) =>> InfiniteT
Proof.A, B: Type
(TtT *** ([|ffA|])) =>> InfiniteT
move => tr0 [tr1 [_ h1]] /=.A, B: Type
tr0, tr1: trace
h1: followsT (singletonT ffA) tr1 tr0
infiniteT tr0
move: tr0 tr1 h1; cofix CIH => tr0 tr1 h1; invs h1.A, B: Type
CIH: forall tr0 tr1 : trace, followsT (singletonT ffA) tr1 tr0 -> infiniteT tr0
tr0: trace
H0: singletonT ffA tr0
infiniteT tr0
A, B: Type
CIH: forall tr0 tr1 : trace, followsT (singletonT ffA) tr1 tr0 -> infiniteT tr0
a: A
b: B
tr, tr': trace
H: followsT (singletonT ffA) tr tr'
infiniteT (Tcons a b tr')
-A, B: Type
CIH: forall tr0 tr1 : trace, followsT (singletonT ffA) tr1 tr0 -> infiniteT tr0
tr0: trace
H0: singletonT ffA tr0
infiniteT tr0
A, B: Type
CIH: forall tr0 tr1 : trace, followsT (singletonT ffA) tr1 tr0 -> infiniteT tr0
a: A
b: B
tr, tr': trace
H: followsT (singletonT ffA) tr tr'
infiniteT (Tcons a b tr') by move: H0 => [a [h1 h2]]; inversion h1.A, B: Type
CIH: forall tr0 tr1 : trace, followsT (singletonT ffA) tr1 tr0 -> infiniteT tr0
a: A
b: B
tr, tr': trace
H: followsT (singletonT ffA) tr tr'
infiniteT (Tcons a b tr')
-A, B: Type
CIH: forall tr0 tr1 : trace, followsT (singletonT ffA) tr1 tr0 -> infiniteT tr0
a: A
b: B
tr, tr': trace
H: followsT (singletonT ffA) tr tr'
infiniteT (Tcons a b tr') exact: infiniteT_delay _ _ (CIH _ _ H).
Qed.

Iteration property

CoInductive iterT (p : trace -> Prop) : trace -> Prop :=
| iterT_stop : forall a,
   iterT p (Tnil a)
| iterT_loop : forall tr tr0,
   p tr ->
   followsT (iterT p) tr tr0 ->
   iterT p tr0.

Lemma iterT_setoidT : forall p (hp : setoidT p), setoidT (iterT p).A, B: Type
forall p : trace -> Prop,
setoidT p -> setoidT (iterT p)
Proof.A, B: Type
forall p : trace -> Prop,
setoidT p -> setoidT (iterT p)
move => p hp.A, B: Type
p: trace -> Prop
hp: setoidT p
setoidT (iterT p) cofix CIH.A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
setoidT (iterT p)
have h0 : forall tr, setoidT (followsT (iterT p) tr).A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
forall tr : trace, setoidT (followsT (iterT p) tr)
A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
h0: forall tr : trace,
setoidT (followsT (iterT p) tr)
setoidT (iterT p)
 cofix CIH1.A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
CIH1: forall tr : trace,
setoidT (followsT (iterT p) tr)
forall tr : trace, setoidT (followsT (iterT p) tr)
A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
h0: forall tr : trace,
setoidT (followsT (iterT p) tr)
setoidT (iterT p) move => tr tr0 h0 tr1 h1.A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
CIH1: forall tr : trace,
setoidT (followsT (iterT p) tr)
tr, tr0: trace
h0: followsT (iterT p) tr tr0
tr1: trace
h1: bisim tr0 tr1
followsT (iterT p) tr tr1
A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
h0: forall tr : trace,
setoidT (followsT (iterT p) tr)
setoidT (iterT p)
 invs h0; last by invs h1; apply: (followsT_delay _ _ (CIH1 _ _ H _ H4)).A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
CIH1: forall tr : trace,
setoidT (followsT (iterT p) tr)
tr0, tr1: trace
h1: bisim tr0 tr1
H0: iterT p tr0
followsT (iterT p) (Tnil (hd tr0)) tr1
A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
h0: forall tr : trace,
setoidT (followsT (iterT p) tr)
setoidT (iterT p)
 apply: followsT_nil; first by symmetry; apply: bisim_hd h1.A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
CIH1: forall tr : trace,
setoidT (followsT (iterT p) tr)
tr0, tr1: trace
h1: bisim tr0 tr1
H0: iterT p tr0
iterT p tr1
A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
h0: forall tr : trace,
setoidT (followsT (iterT p) tr)
setoidT (iterT p)
 exact: CIH _ H0 _ h1.A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
h0: forall tr : trace,
setoidT (followsT (iterT p) tr)
setoidT (iterT p)
move => tr0 h1 tr1 h2; invs h1.A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
h0: forall tr : trace,
setoidT (followsT (iterT p) tr)
a: A
tr1: trace
h2: bisim (Tnil a) tr1
iterT p tr1
A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
h0: forall tr : trace,
setoidT (followsT (iterT p) tr)
tr0, tr1: trace
h2: bisim tr0 tr1
tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
iterT p tr1
-A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
h0: forall tr : trace,
setoidT (followsT (iterT p) tr)
a: A
tr1: trace
h2: bisim (Tnil a) tr1
iterT p tr1
A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
h0: forall tr : trace,
setoidT (followsT (iterT p) tr)
tr0, tr1: trace
h2: bisim tr0 tr1
tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
iterT p tr1 invs h2.A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
h0: forall tr : trace,
setoidT (followsT (iterT p) tr)
a: A
iterT p (Tnil a)
A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
h0: forall tr : trace,
setoidT (followsT (iterT p) tr)
tr0, tr1: trace
h2: bisim tr0 tr1
tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
iterT p tr1 exact: iterT_stop.A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
h0: forall tr : trace,
setoidT (followsT (iterT p) tr)
tr0, tr1: trace
h2: bisim tr0 tr1
tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
iterT p tr1
-A, B: Type
p: trace -> Prop
hp: setoidT p
CIH: setoidT (iterT p)
h0: forall tr : trace,
setoidT (followsT (iterT p) tr)
tr0, tr1: trace
h2: bisim tr0 tr1
tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
iterT p tr1 exact: iterT_loop H (h0 _ _ H0 _ h2).
Qed.

Lemma iterT_cont : forall (p0 p1 : trace -> Prop),
 (forall tr, p0 tr -> p1 tr) ->
 forall tr, iterT p0 tr -> iterT p1 tr.A, B: Type
forall p0 p1 : trace -> Prop,
(forall tr : trace, p0 tr -> p1 tr) ->
forall tr : trace, iterT p0 tr -> iterT p1 tr
Proof.A, B: Type
forall p0 p1 : trace -> Prop,
(forall tr : trace, p0 tr -> p1 tr) ->
forall tr : trace, iterT p0 tr -> iterT p1 tr
move => p0 p1 hp.A, B: Type
p0, p1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
forall tr : trace, iterT p0 tr -> iterT p1 tr cofix CIH.A, B: Type
p0, p1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
CIH: forall tr : trace, iterT p0 tr -> iterT p1 tr
forall tr : trace, iterT p0 tr -> iterT p1 tr
have h : forall tr0 tr1, followsT (iterT p0) tr0 tr1 -> followsT (iterT p1) tr0 tr1.A, B: Type
p0, p1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
CIH: forall tr : trace, iterT p0 tr -> iterT p1 tr
forall tr0 tr1 : trace,
followsT (iterT p0) tr0 tr1 ->
followsT (iterT p1) tr0 tr1
A, B: Type
p0, p1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
CIH: forall tr : trace, iterT p0 tr -> iterT p1 tr
h: forall tr0 tr1 : trace,
followsT (iterT p0) tr0 tr1 ->
followsT (iterT p1) tr0 tr1
forall tr : trace, iterT p0 tr -> iterT p1 tr
 cofix CIH0.A, B: Type
p0, p1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
CIH: forall tr : trace, iterT p0 tr -> iterT p1 tr
CIH0: forall tr0 tr1 : trace,
followsT (iterT p0) tr0 tr1 ->
followsT (iterT p1) tr0 tr1
forall tr0 tr1 : trace,
followsT (iterT p0) tr0 tr1 ->
followsT (iterT p1) tr0 tr1
A, B: Type
p0, p1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
CIH: forall tr : trace, iterT p0 tr -> iterT p1 tr
h: forall tr0 tr1 : trace,
followsT (iterT p0) tr0 tr1 ->
followsT (iterT p1) tr0 tr1
forall tr : trace, iterT p0 tr -> iterT p1 tr move => tr0 tr1 h0.A, B: Type
p0, p1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
CIH: forall tr : trace, iterT p0 tr -> iterT p1 tr
CIH0: forall tr0 tr1 : trace,
followsT (iterT p0) tr0 tr1 ->
followsT (iterT p1) tr0 tr1
tr0, tr1: trace
h0: followsT (iterT p0) tr0 tr1
followsT (iterT p1) tr0 tr1
A, B: Type
p0, p1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
CIH: forall tr : trace, iterT p0 tr -> iterT p1 tr
h: forall tr0 tr1 : trace,
followsT (iterT p0) tr0 tr1 ->
followsT (iterT p1) tr0 tr1
forall tr : trace, iterT p0 tr -> iterT p1 tr
 invs h0; last by apply: (followsT_delay _ _ (CIH0 _ _ H)).A, B: Type
p0, p1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
CIH: forall tr : trace, iterT p0 tr -> iterT p1 tr
CIH0: forall tr0 tr1 : trace,
followsT (iterT p0) tr0 tr1 ->
followsT (iterT p1) tr0 tr1
tr1: trace
H0: iterT p0 tr1
followsT (iterT p1) (Tnil (hd tr1)) tr1
A, B: Type
p0, p1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
CIH: forall tr : trace, iterT p0 tr -> iterT p1 tr
h: forall tr0 tr1 : trace,
followsT (iterT p0) tr0 tr1 ->
followsT (iterT p1) tr0 tr1
forall tr : trace, iterT p0 tr -> iterT p1 tr
 exact/followsT_nil/CIH.A, B: Type
p0, p1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
CIH: forall tr : trace, iterT p0 tr -> iterT p1 tr
h: forall tr0 tr1 : trace,
followsT (iterT p0) tr0 tr1 ->
followsT (iterT p1) tr0 tr1
forall tr : trace, iterT p0 tr -> iterT p1 tr
move => tr0 h0; invs h0; first by apply: iterT_stop.A, B: Type
p0, p1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
CIH: forall tr : trace, iterT p0 tr -> iterT p1 tr
h: forall tr0 tr1 : trace,
followsT (iterT p0) tr0 tr1 ->
followsT (iterT p1) tr0 tr1
tr0, tr: trace
H: p0 tr
H0: followsT (iterT p0) tr tr0
iterT p1 tr0
exact: iterT_loop (hp _ H)  (h _ _ H0).
Qed.

Lemma iterT_appendT_dupT : forall (u : propA) p b tr,
 u (hd tr) -> iterT (appendT p (dupT u b)) tr ->
 followsT (singletonT u) tr tr.A, B: Type
forall (u : propA) (p : trace -> Prop) (b : B)
  (tr : trace),
u (hd tr) ->
iterT (p *+* dupT u b) tr ->
followsT (singletonT u) tr tr
Proof.A, B: Type
forall (u : propA) (p : trace -> Prop) (b : B)
  (tr : trace),
u (hd tr) ->
iterT (p *+* dupT u b) tr ->
followsT (singletonT u) tr tr
move => u p b.A, B: Type
u: propA
p: trace -> Prop
b: B
forall tr : trace,
u (hd tr) ->
iterT (p *+* dupT u b) tr ->
followsT (singletonT u) tr tr cofix CIH.A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
forall tr : trace,
u (hd tr) ->
iterT (p *+* dupT u b) tr ->
followsT (singletonT u) tr tr move => tr h0 h1; invs h1.A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
a: A
h0: u (hd (Tnil a))
followsT (singletonT u) (Tnil a) (Tnil a)
A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
tr: trace
h0: u (hd tr)
tr0: trace
H: (p *+* dupT u b) tr0
H0: followsT (iterT (p *+* dupT u b)) tr0 tr
followsT (singletonT u) tr tr
-A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
a: A
h0: u (hd (Tnil a))
followsT (singletonT u) (Tnil a) (Tnil a)
A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
tr: trace
h0: u (hd tr)
tr0: trace
H: (p *+* dupT u b) tr0
H0: followsT (iterT (p *+* dupT u b)) tr0 tr
followsT (singletonT u) tr tr apply: followsT_nil => //.A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
a: A
h0: u (hd (Tnil a))
singletonT u (Tnil a)
A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
tr: trace
h0: u (hd tr)
tr0: trace
H: (p *+* dupT u b) tr0
H0: followsT (iterT (p *+* dupT u b)) tr0 tr
followsT (singletonT u) tr tr
  exact: nil_singletonT.A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
tr: trace
h0: u (hd tr)
tr0: trace
H: (p *+* dupT u b) tr0
H0: followsT (iterT (p *+* dupT u b)) tr0 tr
followsT (singletonT u) tr tr
-A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
tr: trace
h0: u (hd tr)
tr0: trace
H: (p *+* dupT u b) tr0
H0: followsT (iterT (p *+* dupT u b)) tr0 tr
followsT (singletonT u) tr tr move: H h0 => [tr1 [_ h1]] _.A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
tr, tr0: trace
H0: followsT (iterT (p *+* dupT u b)) tr0 tr
tr1: trace
h1: followsT (dupT u b) tr1 tr0
followsT (singletonT u) tr tr
  move: tr tr1 tr0 h1 H0.A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
forall tr tr1 tr0 : trace,
followsT (dupT u b) tr1 tr0 ->
followsT (iterT (p *+* dupT u b)) tr0 tr ->
followsT (singletonT u) tr tr cofix CIH1.A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
CIH1: forall tr tr1 tr0 : trace,
followsT (dupT u b) tr1 tr0 ->
followsT (iterT (p *+* dupT u b)) tr0 tr ->
followsT (singletonT u) tr tr
forall tr tr1 tr0 : trace,
followsT (dupT u b) tr1 tr0 ->
followsT (iterT (p *+* dupT u b)) tr0 tr ->
followsT (singletonT u) tr tr
  move => tr0 tr1 tr2 h0 h1; invs h0.A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
CIH1: forall tr tr1 tr0 : trace,
followsT (dupT u b) tr1 tr0 ->
followsT (iterT (p *+* dupT u b)) tr0 tr ->
followsT (singletonT u) tr tr
tr0, tr2: trace
h1: followsT (iterT (p *+* dupT u b)) tr2 tr0
H0: dupT u b tr2
followsT (singletonT u) tr0 tr0
A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) ->
iterT (p *+* dupT u b) tr ->
followsT (singletonT u) tr tr
CIH1: forall tr tr1 tr0 : trace,
followsT (dupT u b) tr1 tr0 ->
followsT (iterT (p *+* dupT u b)) tr0 tr ->
followsT (singletonT u) tr tr
tr0: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (p *+* dupT u b))
  (Tcons a b0 tr') tr0
H: followsT (dupT u b) tr tr'
followsT (singletonT u) tr0 tr0
  +A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
CIH1: forall tr tr1 tr0 : trace,
followsT (dupT u b) tr1 tr0 ->
followsT (iterT (p *+* dupT u b)) tr0 tr ->
followsT (singletonT u) tr tr
tr0, tr2: trace
h1: followsT (iterT (p *+* dupT u b)) tr2 tr0
H0: dupT u b tr2
followsT (singletonT u) tr0 tr0
A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) ->
iterT (p *+* dupT u b) tr ->
followsT (singletonT u) tr tr
CIH1: forall tr tr1 tr0 : trace,
followsT (dupT u b) tr1 tr0 ->
followsT (iterT (p *+* dupT u b)) tr0 tr ->
followsT (singletonT u) tr tr
tr0: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (p *+* dupT u b))
  (Tcons a b0 tr') tr0
H: followsT (dupT u b) tr tr'
followsT (singletonT u) tr0 tr0 move: H0 => [a [h0 h3]].A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
CIH1: forall tr tr1 tr0 : trace,
followsT (dupT u b) tr1 tr0 ->
followsT (iterT (p *+* dupT u b)) tr0 tr ->
followsT (singletonT u) tr tr
tr0, tr2: trace
h1: followsT (iterT (p *+* dupT u b)) tr2 tr0
a: A
h0: u a
h3: bisim tr2 (Tcons a b (Tnil a))
followsT (singletonT u) tr0 tr0
A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) ->
iterT (p *+* dupT u b) tr ->
followsT (singletonT u) tr tr
CIH1: forall tr tr1 tr0 : trace,
followsT (dupT u b) tr1 tr0 ->
followsT (iterT (p *+* dupT u b)) tr0 tr ->
followsT (singletonT u) tr tr
tr0: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (p *+* dupT u b))
  (Tcons a b0 tr') tr0
H: followsT (dupT u b) tr tr'
followsT (singletonT u) tr0 tr0
    invs h3; invs H1; invs h1; invs H3.A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
CIH1: forall tr tr1 tr0 : trace,
followsT (dupT u b) tr1 tr0 ->
followsT (iterT (p *+* dupT u b)) tr0 tr ->
followsT (singletonT u) tr tr
tr': trace
h0: u (hd tr')
H1: iterT (p *+* dupT u b) tr'
followsT (singletonT u) (Tcons (hd tr') b tr')
  (Tcons (hd tr') b tr')
A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) ->
iterT (p *+* dupT u b) tr ->
followsT (singletonT u) tr tr
CIH1: forall tr tr1 tr0 : trace,
followsT (dupT u b) tr1 tr0 ->
followsT (iterT (p *+* dupT u b)) tr0 tr ->
followsT (singletonT u) tr tr
tr0: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (p *+* dupT u b))
  (Tcons a b0 tr') tr0
H: followsT (dupT u b) tr tr'
followsT (singletonT u) tr0 tr0
    exact/followsT_delay/CIH.A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
CIH1: forall tr tr1 tr0 : trace,
followsT (dupT u b) tr1 tr0 ->
followsT (iterT (p *+* dupT u b)) tr0 tr ->
followsT (singletonT u) tr tr
tr0: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (p *+* dupT u b))
  (Tcons a b0 tr') tr0
H: followsT (dupT u b) tr tr'
followsT (singletonT u) tr0 tr0
  +A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
CIH1: forall tr tr1 tr0 : trace,
followsT (dupT u b) tr1 tr0 ->
followsT (iterT (p *+* dupT u b)) tr0 tr ->
followsT (singletonT u) tr tr
tr0: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (p *+* dupT u b))
  (Tcons a b0 tr') tr0
H: followsT (dupT u b) tr tr'
followsT (singletonT u) tr0 tr0 invs h1.A, B: Type
u: propA
p: trace -> Prop
b: B
CIH: forall tr : trace,
u (hd tr) -> iterT (p *+* dupT u b) tr -> followsT (singletonT u) tr tr
CIH1: forall tr tr1 tr0 : trace,
followsT (dupT u b) tr1 tr0 ->
followsT (iterT (p *+* dupT u b)) tr0 tr ->
followsT (singletonT u) tr tr
a: A
b0: B
tr, tr', tr'0: trace
H: followsT (dupT u b) tr tr'
H4: followsT (iterT (p *+* dupT u b)) tr' tr'0
followsT (singletonT u) (Tcons a b0 tr'0)
  (Tcons a b0 tr'0) exact: followsT_delay _ _ (CIH1 _ _ _ H H4).
Qed.

Definition IterT (p : propT) : propT :=
let: exist f0 h0 := p in
exist _ (iterT f0) (iterT_setoidT h0).

Lemma IterT_cont : forall p q, p =>> q -> (IterT p) =>> (IterT q).A, B: Type
forall p q : propT, p =>> q -> IterT p =>> IterT q
Proof.A, B: Type
forall p q : propT, p =>> q -> IterT p =>> IterT q
move => [p hp] [q hq] h0 tr0 /=.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
h0: exist (fun p : trace -> Prop => setoidT p) p hp =>>
exist (fun p : trace -> Prop => setoidT p) q hq
tr0: trace
iterT p tr0 -> iterT q tr0
exact: (iterT_cont (fun tr => h0 tr)).
Qed.

Lemma iterT_split_1 : forall p tr, iterT p tr -> (singletonT ttA tr) \/ (appendT p (iterT p) tr).A, B: Type
forall (p : trace -> Prop) (tr : trace),
iterT p tr -> singletonT ttA tr \/ (p *+* iterT p) tr
Proof.A, B: Type
forall (p : trace -> Prop) (tr : trace),
iterT p tr -> singletonT ttA tr \/ (p *+* iterT p) tr
move => p tr h0; invs h0.A, B: Type
p: trace -> Prop
a: A
singletonT ttA (Tnil a) \/ (p *+* iterT p) (Tnil a)
A, B: Type
p: trace -> Prop
tr, tr0: trace
H: p tr0
H0: followsT (iterT p) tr0 tr
singletonT ttA tr \/ (p *+* iterT p) tr
-A, B: Type
p: trace -> Prop
a: A
singletonT ttA (Tnil a) \/ (p *+* iterT p) (Tnil a)
A, B: Type
p: trace -> Prop
tr, tr0: trace
H: p tr0
H0: followsT (iterT p) tr0 tr
singletonT ttA tr \/ (p *+* iterT p) tr by left; apply: nil_singletonT.A, B: Type
p: trace -> Prop
tr, tr0: trace
H: p tr0
H0: followsT (iterT p) tr0 tr
singletonT ttA tr \/ (p *+* iterT p) tr
-A, B: Type
p: trace -> Prop
tr, tr0: trace
H: p tr0
H0: followsT (iterT p) tr0 tr
singletonT ttA tr \/ (p *+* iterT p) tr by right; exists tr0.
Qed.

Lemma IterT_unfold_0 : forall p, IterT p =>> ([|ttA|] orT (p *** IterT p)).A, B: Type
forall p : propT,
IterT p =>> ([|ttA|]) orT p *** IterT p
Proof.A, B: Type
forall p : propT,
IterT p =>> ([|ttA|]) orT p *** IterT p
move => [p hp] tr0 /= h0.A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
h0: iterT p tr0
singletonT ttA tr0 \/ (p *+* iterT p) tr0
exact: iterT_split_1 h0.
Qed.

Lemma iterT_split_2 : forall tr p,
 (singletonT ttA tr) \/ (appendT p (iterT p) tr) -> iterT p tr.A, B: Type
forall (tr : trace) (p : trace -> Prop),
singletonT ttA tr \/ (p *+* iterT p) tr -> iterT p tr
Proof.A, B: Type
forall (tr : trace) (p : trace -> Prop),
singletonT ttA tr \/ (p *+* iterT p) tr -> iterT p tr
move => tr p [[a [h0 h1]] | [tr0 [h0 h1]]].A, B: Type
tr: trace
p: trace -> Prop
a: A
h0: ttA a
h1: bisim tr (Tnil a)
iterT p tr
A, B: Type
tr: trace
p: trace -> Prop
tr0: trace
h0: p tr0
h1: followsT (iterT p) tr0 tr
iterT p tr
-A, B: Type
tr: trace
p: trace -> Prop
a: A
h0: ttA a
h1: bisim tr (Tnil a)
iterT p tr
A, B: Type
tr: trace
p: trace -> Prop
tr0: trace
h0: p tr0
h1: followsT (iterT p) tr0 tr
iterT p tr invs h1.A, B: Type
p: trace -> Prop
a: A
h0: ttA a
iterT p (Tnil a)
A, B: Type
tr: trace
p: trace -> Prop
tr0: trace
h0: p tr0
h1: followsT (iterT p) tr0 tr
iterT p tr exact: iterT_stop.A, B: Type
tr: trace
p: trace -> Prop
tr0: trace
h0: p tr0
h1: followsT (iterT p) tr0 tr
iterT p tr
-A, B: Type
tr: trace
p: trace -> Prop
tr0: trace
h0: p tr0
h1: followsT (iterT p) tr0 tr
iterT p tr exact: iterT_loop h0 h1.
Qed.

Lemma IterT_fold_0 : forall p, ([|ttA|] orT (p *** IterT p)) =>> IterT p.A, B: Type
forall p : propT,
(([|ttA|]) orT p *** IterT p) =>> IterT p
Proof.A, B: Type
forall p : propT,
(([|ttA|]) orT p *** IterT p) =>> IterT p
move => [p hp] tr0 /=.A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
singletonT ttA tr0 \/ (p *+* iterT p) tr0 ->
iterT p tr0
exact: iterT_split_2.
Qed.

Lemma iterT_unfold_1 : forall p tr, (iterT p *+* p) tr -> iterT p tr.A, B: Type
forall (p : trace -> Prop) (tr : trace),
(iterT p *+* p) tr -> iterT p tr
Proof.A, B: Type
forall (p : trace -> Prop) (tr : trace),
(iterT p *+* p) tr -> iterT p tr
move => p tr [tr0 [h0 h1]].A, B: Type
p: trace -> Prop
tr, tr0: trace
h0: iterT p tr0
h1: followsT p tr0 tr
iterT p tr
move: tr0 tr h0 h1.A, B: Type
p: trace -> Prop
forall tr0 tr : trace,
iterT p tr0 -> followsT p tr0 tr -> iterT p tr cofix CIH.A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
forall tr0 tr : trace,
iterT p tr0 -> followsT p tr0 tr -> iterT p tr
move => tr0 tr1 h0 h1; invs h0.A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
tr1: trace
a: A
h1: followsT p (Tnil a) tr1
iterT p tr1
A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
tr0, tr1: trace
h1: followsT p tr0 tr1
tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
iterT p tr1
-A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
tr1: trace
a: A
h1: followsT p (Tnil a) tr1
iterT p tr1
A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
tr0, tr1: trace
h1: followsT p tr0 tr1
tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
iterT p tr1 invs h1.A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
tr1: trace
H1: p tr1
iterT p tr1
A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
tr0, tr1: trace
h1: followsT p tr0 tr1
tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
iterT p tr1 apply: (iterT_loop H1).A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
tr1: trace
H1: p tr1
followsT (iterT p) tr1 tr1
A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
tr0, tr1: trace
h1: followsT p tr0 tr1
tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
iterT p tr1 move: {H1} tr1.A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
forall tr1 : trace, followsT (iterT p) tr1 tr1
A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
tr0, tr1: trace
h1: followsT p tr0 tr1
tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
iterT p tr1 cofix CIH0.A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
CIH0: forall tr1 : trace, followsT (iterT p) tr1 tr1
forall tr1 : trace, followsT (iterT p) tr1 tr1
A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace,
iterT p tr0 -> followsT p tr0 tr -> iterT p tr
tr0, tr1: trace
h1: followsT p tr0 tr1
tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
iterT p tr1
  case => [a | a b tr0]; first by apply: followsT_nil => //; apply: iterT_stop.A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
CIH0: forall tr1 : trace, followsT (iterT p) tr1 tr1
a: A
b: B
tr0: trace
followsT (iterT p) (Tcons a b tr0) (Tcons a b tr0)
A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace,
iterT p tr0 -> followsT p tr0 tr -> iterT p tr
tr0, tr1: trace
h1: followsT p tr0 tr1
tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
iterT p tr1
  exact/followsT_delay/CIH0.A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
tr0, tr1: trace
h1: followsT p tr0 tr1
tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
iterT p tr1
-A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
tr0, tr1: trace
h1: followsT p tr0 tr1
tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
iterT p tr1 apply: (iterT_loop H).A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
tr0, tr1: trace
h1: followsT p tr0 tr1
tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
followsT (iterT p) tr tr1 move: {H} tr tr0 tr1 H0 h1.A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT p tr0 tr1 -> followsT (iterT p) tr tr1 cofix CIH0.A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
CIH0: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT p tr0 tr1 -> followsT (iterT p) tr tr1
forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT p tr0 tr1 -> followsT (iterT p) tr tr1
  move => tr0 tr1 tr2 h0 h1; invs h0.A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
CIH0: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT p tr0 tr1 -> followsT (iterT p) tr tr1
tr1, tr2: trace
h1: followsT p tr1 tr2
H0: iterT p tr1
followsT (iterT p) (Tnil (hd tr1)) tr2
A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace,
iterT p tr0 -> followsT p tr0 tr -> iterT p tr
CIH0: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT p tr0 tr1 -> followsT (iterT p) tr tr1
tr2: trace
a: A
b: B
tr, tr': trace
h1: followsT p (Tcons a b tr') tr2
H: followsT (iterT p) tr tr'
followsT (iterT p) (Tcons a b tr) tr2
  +A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
CIH0: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT p tr0 tr1 -> followsT (iterT p) tr tr1
tr1, tr2: trace
h1: followsT p tr1 tr2
H0: iterT p tr1
followsT (iterT p) (Tnil (hd tr1)) tr2
A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace,
iterT p tr0 -> followsT p tr0 tr -> iterT p tr
CIH0: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT p tr0 tr1 -> followsT (iterT p) tr tr1
tr2: trace
a: A
b: B
tr, tr': trace
h1: followsT p (Tcons a b tr') tr2
H: followsT (iterT p) tr tr'
followsT (iterT p) (Tcons a b tr) tr2 rewrite (followsT_hd h1).A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
CIH0: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT p tr0 tr1 -> followsT (iterT p) tr tr1
tr1, tr2: trace
h1: followsT p tr1 tr2
H0: iterT p tr1
followsT (iterT p) (Tnil (hd tr2)) tr2
A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace,
iterT p tr0 -> followsT p tr0 tr -> iterT p tr
CIH0: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT p tr0 tr1 -> followsT (iterT p) tr tr1
tr2: trace
a: A
b: B
tr, tr': trace
h1: followsT p (Tcons a b tr') tr2
H: followsT (iterT p) tr tr'
followsT (iterT p) (Tcons a b tr) tr2
    exact: followsT_nil _ (CIH _ _ H0 h1).A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
CIH0: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT p tr0 tr1 -> followsT (iterT p) tr tr1
tr2: trace
a: A
b: B
tr, tr': trace
h1: followsT p (Tcons a b tr') tr2
H: followsT (iterT p) tr tr'
followsT (iterT p) (Tcons a b tr) tr2
  +A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
CIH0: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT p tr0 tr1 -> followsT (iterT p) tr tr1
tr2: trace
a: A
b: B
tr, tr': trace
h1: followsT p (Tcons a b tr') tr2
H: followsT (iterT p) tr tr'
followsT (iterT p) (Tcons a b tr) tr2 invs h1.A, B: Type
p: trace -> Prop
CIH: forall tr0 tr : trace, iterT p tr0 -> followsT p tr0 tr -> iterT p tr
CIH0: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT p tr0 tr1 -> followsT (iterT p) tr tr1
a: A
b: B
tr, tr', tr'0: trace
H: followsT (iterT p) tr tr'
H4: followsT p tr' tr'0
followsT (iterT p) (Tcons a b tr) (Tcons a b tr'0)
    exact: followsT_delay _ _ (CIH0 _ _ _ H H4).
Qed.

Lemma IterT_unfold_1 : forall p, (IterT p *** p) =>> IterT p.A, B: Type
forall p : propT, (IterT p *** p) =>> IterT p
Proof.A, B: Type
forall p : propT, (IterT p *** p) =>> IterT p
move => [p hp] tr /= h0.A, B: Type
p: trace -> Prop
hp: setoidT p
tr: trace
h0: (iterT p *+* p) tr
iterT p tr
exact: iterT_unfold_1 h0.
Qed.

Lemma IterT_unfold_2 : forall p, ([|ttA|] orT (IterT p *** p)) =>> IterT p.A, B: Type
forall p : propT,
(([|ttA|]) orT IterT p *** p) =>> IterT p
Proof.A, B: Type
forall p : propT,
(([|ttA|]) orT IterT p *** p) =>> IterT p
move => [p hp] tr0 /= [[a [_ h0]] | H].A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
a: A
h0: bisim tr0 (Tnil a)
iterT p tr0
A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
H: (iterT p *+* p) tr0
iterT p tr0
-A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
a: A
h0: bisim tr0 (Tnil a)
iterT p tr0
A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
H: (iterT p *+* p) tr0
iterT p tr0 invs h0.A, B: Type
p: trace -> Prop
hp: setoidT p
a: A
iterT p (Tnil a)
A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
H: (iterT p *+* p) tr0
iterT p tr0 exact: iterT_stop.A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
H: (iterT p *+* p) tr0
iterT p tr0
-A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
H: (iterT p *+* p) tr0
iterT p tr0 exact: iterT_unfold_1 H.
Qed.

Lemma stop_IterT : forall p, [|ttA|] =>> IterT p.A, B: Type
forall p : propT, ([|ttA|]) =>> IterT p
Proof.A, B: Type
forall p : propT, ([|ttA|]) =>> IterT p
move => [p hp] /= t0 [x [_ h0]]; invs h0 => /=.A, B: Type
p: trace -> Prop
hp: setoidT p
x: A
iterT p (Tnil x)
exact: iterT_stop.
Qed.

Lemma IterT_fold_L : forall p, (p *** IterT p) =>> IterT p.A, B: Type
forall p : propT, (p *** IterT p) =>> IterT p
Proof.A, B: Type
forall p : propT, (p *** IterT p) =>> IterT p
move => [p hp] tr0 /= [tr1 [h0 h1]].A, B: Type
p: trace -> Prop
hp: setoidT p
tr0, tr1: trace
h0: p tr1
h1: followsT (iterT p) tr1 tr0
iterT p tr0
exact: (iterT_loop h0).
Qed.

Lemma iterT_iterT_2 : forall p tr, iterT p tr -> appendT (iterT p) (iterT p) tr.A, B: Type
forall (p : trace -> Prop) (tr : trace),
iterT p tr -> (iterT p *+* iterT p) tr
Proof.A, B: Type
forall (p : trace -> Prop) (tr : trace),
iterT p tr -> (iterT p *+* iterT p) tr
move => p tr0 h0.A, B: Type
p: trace -> Prop
tr0: trace
h0: iterT p tr0
(iterT p *+* iterT p) tr0
exists tr0; split => //.A, B: Type
p: trace -> Prop
tr0: trace
h0: iterT p tr0
followsT (iterT p) tr0 tr0
move: {h0} tr0.A, B: Type
p: trace -> Prop
forall tr0 : trace, followsT (iterT p) tr0 tr0 cofix CIH.A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (iterT p) tr0 tr0
forall tr0 : trace, followsT (iterT p) tr0 tr0
case => [a | a b tr0].A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (iterT p) tr0 tr0
a: A
followsT (iterT p) (Tnil a) (Tnil a)
A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (iterT p) tr0 tr0
a: A
b: B
tr0: trace
followsT (iterT p) (Tcons a b tr0) (Tcons a b tr0)
-A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (iterT p) tr0 tr0
a: A
followsT (iterT p) (Tnil a) (Tnil a)
A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (iterT p) tr0 tr0
a: A
b: B
tr0: trace
followsT (iterT p) (Tcons a b tr0) (Tcons a b tr0) apply: followsT_nil => //.A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (iterT p) tr0 tr0
a: A
iterT p (Tnil a)
A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (iterT p) tr0 tr0
a: A
b: B
tr0: trace
followsT (iterT p) (Tcons a b tr0) (Tcons a b tr0) exact: iterT_stop.A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (iterT p) tr0 tr0
a: A
b: B
tr0: trace
followsT (iterT p) (Tcons a b tr0) (Tcons a b tr0)
-A, B: Type
p: trace -> Prop
CIH: forall tr0 : trace, followsT (iterT p) tr0 tr0
a: A
b: B
tr0: trace
followsT (iterT p) (Tcons a b tr0) (Tcons a b tr0) exact/followsT_delay/CIH.
Qed.

Lemma IterT_IterT_2 : forall p, IterT p =>> (IterT p *** IterT p).A, B: Type
forall p : propT, IterT p =>> IterT p *** IterT p
Proof.A, B: Type
forall p : propT, IterT p =>> IterT p *** IterT p
move => [p hp] tr0 /=.A, B: Type
p: trace -> Prop
hp: setoidT p
tr0: trace
iterT p tr0 -> (iterT p *+* iterT p) tr0
exact: iterT_iterT_2.
Qed.

Lemma iterT_iterT : forall p tr, appendT (iterT p) (iterT p) tr -> (iterT p) tr.A, B: Type
forall (p : trace -> Prop) (tr : trace),
(iterT p *+* iterT p) tr -> iterT p tr
Proof.A, B: Type
forall (p : trace -> Prop) (tr : trace),
(iterT p *+* iterT p) tr -> iterT p tr
move => p tr0 [tr1 [h0 h1]].A, B: Type
p: trace -> Prop
tr0, tr1: trace
h0: iterT p tr1
h1: followsT (iterT p) tr1 tr0
iterT p tr0
move: tr1 tr0 h0 h1.A, B: Type
p: trace -> Prop
forall tr1 tr0 : trace,
iterT p tr1 ->
followsT (iterT p) tr1 tr0 -> iterT p tr0 cofix CIH.A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 -> followsT (iterT p) tr1 tr0 -> iterT p tr0
forall tr1 tr0 : trace,
iterT p tr1 ->
followsT (iterT p) tr1 tr0 -> iterT p tr0 move => tr0 tr1 h0; invs h0 => h0.A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 -> followsT (iterT p) tr1 tr0 -> iterT p tr0
tr1: trace
a: A
h0: followsT (iterT p) (Tnil a) tr1
iterT p tr1
A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 -> followsT (iterT p) tr1 tr0 -> iterT p tr0
tr0, tr1, tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
h0: followsT (iterT p) tr0 tr1
iterT p tr1
-A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 -> followsT (iterT p) tr1 tr0 -> iterT p tr0
tr1: trace
a: A
h0: followsT (iterT p) (Tnil a) tr1
iterT p tr1
A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 -> followsT (iterT p) tr1 tr0 -> iterT p tr0
tr0, tr1, tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
h0: followsT (iterT p) tr0 tr1
iterT p tr1 by invs h0.A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 -> followsT (iterT p) tr1 tr0 -> iterT p tr0
tr0, tr1, tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
h0: followsT (iterT p) tr0 tr1
iterT p tr1
-A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 -> followsT (iterT p) tr1 tr0 -> iterT p tr0
tr0, tr1, tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
h0: followsT (iterT p) tr0 tr1
iterT p tr1 apply: (iterT_loop H).A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 -> followsT (iterT p) tr1 tr0 -> iterT p tr0
tr0, tr1, tr: trace
H: p tr
H0: followsT (iterT p) tr tr0
h0: followsT (iterT p) tr0 tr1
followsT (iterT p) tr tr1
  move: {H} tr tr0 tr1 H0 h0.A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 -> followsT (iterT p) tr1 tr0 -> iterT p tr0
forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT (iterT p) tr0 tr1 ->
followsT (iterT p) tr tr1 cofix CIH2.A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 -> followsT (iterT p) tr1 tr0 -> iterT p tr0
CIH2: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT (iterT p) tr0 tr1 ->
followsT (iterT p) tr tr1
forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT (iterT p) tr0 tr1 ->
followsT (iterT p) tr tr1 move => tr0 tr1 tr2 h0; invs h0 => h0.A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 -> followsT (iterT p) tr1 tr0 -> iterT p tr0
CIH2: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT (iterT p) tr0 tr1 ->
followsT (iterT p) tr tr1
tr1, tr2: trace
H0: iterT p tr1
h0: followsT (iterT p) tr1 tr2
followsT (iterT p) (Tnil (hd tr1)) tr2
A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 ->
followsT (iterT p) tr1 tr0 -> iterT p tr0
CIH2: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT (iterT p) tr0 tr1 ->
followsT (iterT p) tr tr1
tr2: trace
a: A
b: B
tr, tr': trace
H: followsT (iterT p) tr tr'
h0: followsT (iterT p) (Tcons a b tr') tr2
followsT (iterT p) (Tcons a b tr) tr2
  +A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 -> followsT (iterT p) tr1 tr0 -> iterT p tr0
CIH2: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT (iterT p) tr0 tr1 ->
followsT (iterT p) tr tr1
tr1, tr2: trace
H0: iterT p tr1
h0: followsT (iterT p) tr1 tr2
followsT (iterT p) (Tnil (hd tr1)) tr2
A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 ->
followsT (iterT p) tr1 tr0 -> iterT p tr0
CIH2: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT (iterT p) tr0 tr1 ->
followsT (iterT p) tr tr1
tr2: trace
a: A
b: B
tr, tr': trace
H: followsT (iterT p) tr tr'
h0: followsT (iterT p) (Tcons a b tr') tr2
followsT (iterT p) (Tcons a b tr) tr2 rewrite (followsT_hd h0).A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 -> followsT (iterT p) tr1 tr0 -> iterT p tr0
CIH2: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT (iterT p) tr0 tr1 ->
followsT (iterT p) tr tr1
tr1, tr2: trace
H0: iterT p tr1
h0: followsT (iterT p) tr1 tr2
followsT (iterT p) (Tnil (hd tr2)) tr2
A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 ->
followsT (iterT p) tr1 tr0 -> iterT p tr0
CIH2: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT (iterT p) tr0 tr1 ->
followsT (iterT p) tr tr1
tr2: trace
a: A
b: B
tr, tr': trace
H: followsT (iterT p) tr tr'
h0: followsT (iterT p) (Tcons a b tr') tr2
followsT (iterT p) (Tcons a b tr) tr2
    exact: followsT_nil _ (CIH _ _ H0 h0).A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 -> followsT (iterT p) tr1 tr0 -> iterT p tr0
CIH2: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT (iterT p) tr0 tr1 ->
followsT (iterT p) tr tr1
tr2: trace
a: A
b: B
tr, tr': trace
H: followsT (iterT p) tr tr'
h0: followsT (iterT p) (Tcons a b tr') tr2
followsT (iterT p) (Tcons a b tr) tr2
  +A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 -> followsT (iterT p) tr1 tr0 -> iterT p tr0
CIH2: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT (iterT p) tr0 tr1 ->
followsT (iterT p) tr tr1
tr2: trace
a: A
b: B
tr, tr': trace
H: followsT (iterT p) tr tr'
h0: followsT (iterT p) (Tcons a b tr') tr2
followsT (iterT p) (Tcons a b tr) tr2 invs h0.A, B: Type
p: trace -> Prop
CIH: forall tr1 tr0 : trace,
iterT p tr1 -> followsT (iterT p) tr1 tr0 -> iterT p tr0
CIH2: forall tr tr0 tr1 : trace,
followsT (iterT p) tr tr0 ->
followsT (iterT p) tr0 tr1 ->
followsT (iterT p) tr tr1
a: A
b: B
tr, tr': trace
H: followsT (iterT p) tr tr'
tr'0: trace
H4: followsT (iterT p) tr' tr'0
followsT (iterT p) (Tcons a b tr) (Tcons a b tr'0)
    exact: followsT_delay _ _ (CIH2 _ _ _ H H4).
Qed.

Lemma IterT_IterT : forall p, (IterT p *** IterT p) =>> IterT p.A, B: Type
forall p : propT, (IterT p *** IterT p) =>> IterT p
Proof.A, B: Type
forall p : propT, (IterT p *** IterT p) =>> IterT p move => [p hp] tr /=.A, B: Type
p: trace -> Prop
hp: setoidT p
tr: trace
(iterT p *+* iterT p) tr -> iterT p tr exact: iterT_iterT. Qed.

Lemma IterT_DupT : forall v b,
 ([|v|] *** (IterT (TtT *** <<v;b>>))) =>> (TtT *** [|v|]).A, B: Type
forall (v : propA) (b : B),
(([|v|]) *** IterT (TtT *** (<< v; b >>))) =>>
TtT *** ([|v|])
Proof.A, B: Type
forall (v : propA) (b : B),
(([|v|]) *** IterT (TtT *** (<< v; b >>))) =>>
TtT *** ([|v|])
move => v b tr0 [tr1 [[a [h0 h2]] h1]]; invs h2; invs h1 => /=.A, B: Type
v: propA
b: B
tr0: trace
h0: v (hd tr0)
H1: iterT (ttT *+* dupT v b) tr0
(ttT *+* singletonT v) tr0
exists tr0.A, B: Type
v: propA
b: B
tr0: trace
h0: v (hd tr0)
H1: iterT (ttT *+* dupT v b) tr0
ttT tr0 /\ followsT (singletonT v) tr0 tr0 split => //.A, B: Type
v: propA
b: B
tr0: trace
h0: v (hd tr0)
H1: iterT (ttT *+* dupT v b) tr0
followsT (singletonT v) tr0 tr0
move: tr0 h0 H1.A, B: Type
v: propA
b: B
forall tr0 : trace,
v (hd tr0) ->
iterT (ttT *+* dupT v b) tr0 ->
followsT (singletonT v) tr0 tr0 cofix CIH.A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
forall tr0 : trace,
v (hd tr0) ->
iterT (ttT *+* dupT v b) tr0 ->
followsT (singletonT v) tr0 tr0 move => tr0 h0 h1; invs h1.A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
a: A
h0: v (hd (Tnil a))
followsT (singletonT v) (Tnil a) (Tnil a)
A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
tr0: trace
h0: v (hd tr0)
tr: trace
H: (ttT *+* dupT v b) tr
H0: followsT (iterT (ttT *+* dupT v b)) tr tr0
followsT (singletonT v) tr0 tr0
-A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
a: A
h0: v (hd (Tnil a))
followsT (singletonT v) (Tnil a) (Tnil a)
A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
tr0: trace
h0: v (hd tr0)
tr: trace
H: (ttT *+* dupT v b) tr
H0: followsT (iterT (ttT *+* dupT v b)) tr tr0
followsT (singletonT v) tr0 tr0 apply: followsT_nil => //=.A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
a: A
h0: v (hd (Tnil a))
singletonT v (Tnil a)
A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
tr0: trace
h0: v (hd tr0)
tr: trace
H: (ttT *+* dupT v b) tr
H0: followsT (iterT (ttT *+* dupT v b)) tr tr0
followsT (singletonT v) tr0 tr0 exact: nil_singletonT.A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
tr0: trace
h0: v (hd tr0)
tr: trace
H: (ttT *+* dupT v b) tr
H0: followsT (iterT (ttT *+* dupT v b)) tr tr0
followsT (singletonT v) tr0 tr0
-A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
tr0: trace
h0: v (hd tr0)
tr: trace
H: (ttT *+* dupT v b) tr
H0: followsT (iterT (ttT *+* dupT v b)) tr tr0
followsT (singletonT v) tr0 tr0 move: H h0 => [tr1 [_ h1]] _.A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
tr0, tr: trace
H0: followsT (iterT (ttT *+* dupT v b)) tr tr0
tr1: trace
h1: followsT (dupT v b) tr1 tr
followsT (singletonT v) tr0 tr0
  move: tr1 tr tr0 h1 H0.A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0 cofix CIH0.A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0 move => tr0 tr1 tr2 h0 h1; invs h0.A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr1, tr2: trace
h1: followsT (iterT (ttT *+* dupT v b)) tr1 tr2
H0: dupT v b tr1
followsT (singletonT v) tr2 tr2
A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) ->
iterT (ttT *+* dupT v b) tr0 ->
followsT (singletonT v) tr0 tr0
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr2: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (ttT *+* dupT v b))
  (Tcons a b0 tr') tr2
H: followsT (dupT v b) tr tr'
followsT (singletonT v) tr2 tr2
  +A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr1, tr2: trace
h1: followsT (iterT (ttT *+* dupT v b)) tr1 tr2
H0: dupT v b tr1
followsT (singletonT v) tr2 tr2
A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) ->
iterT (ttT *+* dupT v b) tr0 ->
followsT (singletonT v) tr0 tr0
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr2: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (ttT *+* dupT v b))
  (Tcons a b0 tr') tr2
H: followsT (dupT v b) tr tr'
followsT (singletonT v) tr2 tr2 move: H0 => [a [h0 h2]].A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr1, tr2: trace
h1: followsT (iterT (ttT *+* dupT v b)) tr1 tr2
a: A
h0: v a
h2: bisim tr1 (Tcons a b (Tnil a))
followsT (singletonT v) tr2 tr2
A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) ->
iterT (ttT *+* dupT v b) tr0 ->
followsT (singletonT v) tr0 tr0
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr2: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (ttT *+* dupT v b))
  (Tcons a b0 tr') tr2
H: followsT (dupT v b) tr tr'
followsT (singletonT v) tr2 tr2
    invs h2; invs H1; invs h1; invs H3.A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr': trace
h0: v (hd tr')
H1: iterT (ttT *+* dupT v b) tr'
followsT (singletonT v) (Tcons (hd tr') b tr')
  (Tcons (hd tr') b tr')
A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) ->
iterT (ttT *+* dupT v b) tr0 ->
followsT (singletonT v) tr0 tr0
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr2: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (ttT *+* dupT v b))
  (Tcons a b0 tr') tr2
H: followsT (dupT v b) tr tr'
followsT (singletonT v) tr2 tr2
    exact/followsT_delay/CIH.A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr2: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (ttT *+* dupT v b))
  (Tcons a b0 tr') tr2
H: followsT (dupT v b) tr tr'
followsT (singletonT v) tr2 tr2
  +A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr2: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (ttT *+* dupT v b))
  (Tcons a b0 tr') tr2
H: followsT (dupT v b) tr tr'
followsT (singletonT v) tr2 tr2 invs h1.A, B: Type
v: propA
b: B
CIH: forall tr0 : trace,
v (hd tr0) -> iterT (ttT *+* dupT v b) tr0 -> followsT (singletonT v) tr0 tr0
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
a: A
b0: B
tr, tr', tr'0: trace
H: followsT (dupT v b) tr tr'
H4: followsT (iterT (ttT *+* dupT v b)) tr' tr'0
followsT (singletonT v) (Tcons a b0 tr'0)
  (Tcons a b0 tr'0) exact: followsT_delay _ _ (CIH0 _ _ _ H H4).
Qed.

Last property

Definition lastA (p : trace -> Prop) : propA :=
fun a => exists tr, p tr /\ finalTA tr a.

Lemma lastA_cont : forall (p q : trace -> Prop),
 (forall tr, p tr -> q tr) ->
 lastA p ->> lastA q.A, B: Type
forall p q : trace -> Prop,
(forall tr : trace, p tr -> q tr) ->
lastA p ->> lastA q
Proof.A, B: Type
forall p q : trace -> Prop,
(forall tr : trace, p tr -> q tr) ->
lastA p ->> lastA q
move => p0 p1 hp a [tr [h0 h1]].A, B: Type
p0, p1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
a: A
tr: trace
h0: p0 tr
h1: finalTA tr a
lastA p1 a
exists tr; split; first by apply: hp _ h0.A, B: Type
p0, p1: trace -> Prop
hp: forall tr : trace, p0 tr -> p1 tr
a: A
tr: trace
h0: p0 tr
h1: finalTA tr a
finalTA tr a
exact: h1.
Qed.

Definition LastA (p : propT) : propA :=
let: exist f0 h0 := p in lastA f0.

Lemma LastA_cont : forall p q, p =>> q -> LastA p ->> LastA q.A, B: Type
forall p q : propT, p =>> q -> LastA p ->> LastA q
Proof.A, B: Type
forall p q : propT, p =>> q -> LastA p ->> LastA q
move => [f hf] [g hg] /= h0.A, B: Type
f: trace -> Prop
hf: setoidT f
g: trace -> Prop
hg: setoidT g
h0: exist (fun p : trace -> Prop => setoidT p) f hf =>>
exist (fun p : trace -> Prop => setoidT p) g hg
lastA f ->> lastA g
exact/lastA_cont/h0.
Qed.

Lemma LastA_SingletonT_fold : forall u, LastA ([|u|]) ->> u.A, B: Type
forall u : propA, LastA ([|u|]) ->> u
Proof.A, B: Type
forall u : propA, LastA ([|u|]) ->> u
by move => u a [tr0 [[st1 [h1 h3]] h2]]; invs h3; invs h2.
Qed.

Lemma LastA_SingletonT_unfold : forall u, u ->> LastA ([|u|]).A, B: Type
forall u : propA, u ->> LastA ([|u|])
Proof.A, B: Type
forall u : propA, u ->> LastA ([|u|])
move => u a h0.A, B: Type
u: propA
a: A
h0: u a
LastA ([|u|]) a
exists (Tnil a); split.A, B: Type
u: propA
a: A
h0: u a
singletonT u (Tnil a)
A, B: Type
u: propA
a: A
h0: u a
finalTA (Tnil a) a
-A, B: Type
u: propA
a: A
h0: u a
singletonT u (Tnil a)
A, B: Type
u: propA
a: A
h0: u a
finalTA (Tnil a) a exact: nil_singletonT.A, B: Type
u: propA
a: A
h0: u a
finalTA (Tnil a) a
-A, B: Type
u: propA
a: A
h0: u a
finalTA (Tnil a) a exact: finalTA_nil.
Qed.

Lemma lastA_appendA : forall p q a, lastA (appendT p q) a -> lastA q a.A, B: Type
forall (p q : trace -> Prop) (a : A),
lastA (p *+* q) a -> lastA q a
Proof.A, B: Type
forall (p q : trace -> Prop) (a : A),
lastA (p *+* q) a -> lastA q a
move => p q a [tr0 [[tr [_ h2]] h1]].A, B: Type
p, q: trace -> Prop
a: A
tr0, tr: trace
h2: followsT q tr tr0
h1: finalTA tr0 a
lastA q a
move: h1 tr h2; elim => {tr0 a} [a | a b a' tr0 Hfinal IH] tr h0; invs h0.A, B: Type
p, q: trace -> Prop
a: A
H0: q (Tnil a)
lastA q a
A, B: Type
p, q: trace -> Prop
a: A
b: B
a': A
tr0: trace
Hfinal: finalTA tr0 a'
IH: forall tr : trace,
followsT q tr tr0 -> lastA q a'
H0: q (Tcons a b tr0)
lastA q a'
A, B: Type
p, q: trace -> Prop
a: A
b: B
a': A
tr0: trace
Hfinal: finalTA tr0 a'
IH: forall tr : trace,
followsT q tr tr0 -> lastA q a'
tr1: trace
H1: followsT q tr1 tr0
lastA q a'
-A, B: Type
p, q: trace -> Prop
a: A
H0: q (Tnil a)
lastA q a
A, B: Type
p, q: trace -> Prop
a: A
b: B
a': A
tr0: trace
Hfinal: finalTA tr0 a'
IH: forall tr : trace,
followsT q tr tr0 -> lastA q a'
H0: q (Tcons a b tr0)
lastA q a'
A, B: Type
p, q: trace -> Prop
a: A
b: B
a': A
tr0: trace
Hfinal: finalTA tr0 a'
IH: forall tr : trace,
followsT q tr tr0 -> lastA q a'
tr1: trace
H1: followsT q tr1 tr0
lastA q a' exists (Tnil a).A, B: Type
p, q: trace -> Prop
a: A
H0: q (Tnil a)
q (Tnil a) /\ finalTA (Tnil a) a
A, B: Type
p, q: trace -> Prop
a: A
b: B
a': A
tr0: trace
Hfinal: finalTA tr0 a'
IH: forall tr : trace,
followsT q tr tr0 -> lastA q a'
H0: q (Tcons a b tr0)
lastA q a'
A, B: Type
p, q: trace -> Prop
a: A
b: B
a': A
tr0: trace
Hfinal: finalTA tr0 a'
IH: forall tr : trace,
followsT q tr tr0 -> lastA q a'
tr1: trace
H1: followsT q tr1 tr0
lastA q a' by split; last by apply: finalTA_nil.A, B: Type
p, q: trace -> Prop
a: A
b: B
a': A
tr0: trace
Hfinal: finalTA tr0 a'
IH: forall tr : trace,
followsT q tr tr0 -> lastA q a'
H0: q (Tcons a b tr0)
lastA q a'
A, B: Type
p, q: trace -> Prop
a: A
b: B
a': A
tr0: trace
Hfinal: finalTA tr0 a'
IH: forall tr : trace,
followsT q tr tr0 -> lastA q a'
tr1: trace
H1: followsT q tr1 tr0
lastA q a'
-A, B: Type
p, q: trace -> Prop
a: A
b: B
a': A
tr0: trace
Hfinal: finalTA tr0 a'
IH: forall tr : trace,
followsT q tr tr0 -> lastA q a'
H0: q (Tcons a b tr0)
lastA q a'
A, B: Type
p, q: trace -> Prop
a: A
b: B
a': A
tr0: trace
Hfinal: finalTA tr0 a'
IH: forall tr : trace,
followsT q tr tr0 -> lastA q a'
tr1: trace
H1: followsT q tr1 tr0
lastA q a' exists (Tcons a b tr0).A, B: Type
p, q: trace -> Prop
a: A
b: B
a': A
tr0: trace
Hfinal: finalTA tr0 a'
IH: forall tr : trace,
followsT q tr tr0 -> lastA q a'
H0: q (Tcons a b tr0)
q (Tcons a b tr0) /\ finalTA (Tcons a b tr0) a'
A, B: Type
p, q: trace -> Prop
a: A
b: B
a': A
tr0: trace
Hfinal: finalTA tr0 a'
IH: forall tr : trace,
followsT q tr tr0 -> lastA q a'
tr1: trace
H1: followsT q tr1 tr0
lastA q a' by split; last by apply: finalTA_delay.A, B: Type
p, q: trace -> Prop
a: A
b: B
a': A
tr0: trace
Hfinal: finalTA tr0 a'
IH: forall tr : trace,
followsT q tr tr0 -> lastA q a'
tr1: trace
H1: followsT q tr1 tr0
lastA q a'
-A, B: Type
p, q: trace -> Prop
a: A
b: B
a': A
tr0: trace
Hfinal: finalTA tr0 a'
IH: forall tr : trace,
followsT q tr tr0 -> lastA q a'
tr1: trace
H1: followsT q tr1 tr0
lastA q a' exact: IH _ H1.
Qed.

Lemma LastA_AppendA : forall p v, LastA (p *** [|v|]) ->> v.A, B: Type
forall (p : propT) (v : propA),
LastA (p *** ([|v|])) ->> v
Proof.A, B: Type
forall (p : propT) (v : propA),
LastA (p *** ([|v|])) ->> v
move => [p hp] v /= a [tr [[tr' [_ h0]] h1]].A, B: Type
p: trace -> Prop
hp: setoidT p
v: propA
a: A
tr, tr': trace
h0: followsT (singletonT v) tr' tr
h1: finalTA tr a
v a
move: h1 tr' h0; elim => {tr a} [a | a b a' tr Hfinal IH] tr0 h0; invs h0.A, B: Type
p: trace -> Prop
hp: setoidT p
v: propA
a: A
H0: singletonT v (Tnil a)
v a
A, B: Type
p: trace -> Prop
hp: setoidT p
v: propA
a: A
b: B
a': A
tr: trace
Hfinal: finalTA tr a'
IH: forall tr' : trace,
followsT (singletonT v) tr' tr -> v a'
H0: singletonT v (Tcons a b tr)
v a'
A, B: Type
p: trace -> Prop
hp: setoidT p
v: propA
a: A
b: B
a': A
tr: trace
Hfinal: finalTA tr a'
IH: forall tr' : trace,
followsT (singletonT v) tr' tr -> v a'
tr1: trace
H1: followsT (singletonT v) tr1 tr
v a'
-A, B: Type
p: trace -> Prop
hp: setoidT p
v: propA
a: A
H0: singletonT v (Tnil a)
v a
A, B: Type
p: trace -> Prop
hp: setoidT p
v: propA
a: A
b: B
a': A
tr: trace
Hfinal: finalTA tr a'
IH: forall tr' : trace,
followsT (singletonT v) tr' tr -> v a'
H0: singletonT v (Tcons a b tr)
v a'
A, B: Type
p: trace -> Prop
hp: setoidT p
v: propA
a: A
b: B
a': A
tr: trace
Hfinal: finalTA tr a'
IH: forall tr' : trace,
followsT (singletonT v) tr' tr -> v a'
tr1: trace
H1: followsT (singletonT v) tr1 tr
v a' by move: H0 => [a0 [h0 h1]]; invs h1.A, B: Type
p: trace -> Prop
hp: setoidT p
v: propA
a: A
b: B
a': A
tr: trace
Hfinal: finalTA tr a'
IH: forall tr' : trace,
followsT (singletonT v) tr' tr -> v a'
H0: singletonT v (Tcons a b tr)
v a'
A, B: Type
p: trace -> Prop
hp: setoidT p
v: propA
a: A
b: B
a': A
tr: trace
Hfinal: finalTA tr a'
IH: forall tr' : trace,
followsT (singletonT v) tr' tr -> v a'
tr1: trace
H1: followsT (singletonT v) tr1 tr
v a'
-A, B: Type
p: trace -> Prop
hp: setoidT p
v: propA
a: A
b: B
a': A
tr: trace
Hfinal: finalTA tr a'
IH: forall tr' : trace,
followsT (singletonT v) tr' tr -> v a'
H0: singletonT v (Tcons a b tr)
v a'
A, B: Type
p: trace -> Prop
hp: setoidT p
v: propA
a: A
b: B
a': A
tr: trace
Hfinal: finalTA tr a'
IH: forall tr' : trace,
followsT (singletonT v) tr' tr -> v a'
tr1: trace
H1: followsT (singletonT v) tr1 tr
v a' by move: H0 => [a0 [_ h0]]; invs h0.A, B: Type
p: trace -> Prop
hp: setoidT p
v: propA
a: A
b: B
a': A
tr: trace
Hfinal: finalTA tr a'
IH: forall tr' : trace,
followsT (singletonT v) tr' tr -> v a'
tr1: trace
H1: followsT (singletonT v) tr1 tr
v a'
-A, B: Type
p: trace -> Prop
hp: setoidT p
v: propA
a: A
b: B
a': A
tr: trace
Hfinal: finalTA tr a'
IH: forall tr' : trace,
followsT (singletonT v) tr' tr -> v a'
tr1: trace
H1: followsT (singletonT v) tr1 tr
v a' exact: IH _ H1.
Qed.

Lemma LastA_andA : forall p u, ((LastA p) andA u) ->> LastA (p *** [|u|]).A, B: Type
forall (p : propT) (u : propA),
(LastA p andA u) ->> LastA (p *** ([|u|]))
Proof.A, B: Type
forall (p : propT) (u : propA),
(LastA p andA u) ->> LastA (p *** ([|u|]))
move => [p hp] u a [[tr0 [h2 h3]] h1].A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
a: A
tr0: trace
h2: p tr0
h3: finalTA tr0 a
h1: u a
LastA
  (exist (fun p : trace -> Prop => setoidT p) p hp ***
   ([|u|])) a
exists tr0.A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
a: A
tr0: trace
h2: p tr0
h3: finalTA tr0 a
h1: u a
(p *+* singletonT u) tr0 /\ finalTA tr0 a split => //.A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
a: A
tr0: trace
h2: p tr0
h3: finalTA tr0 a
h1: u a
(p *+* singletonT u) tr0 exists tr0.A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
a: A
tr0: trace
h2: p tr0
h3: finalTA tr0 a
h1: u a
p tr0 /\ followsT (singletonT u) tr0 tr0 split => //.A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
a: A
tr0: trace
h2: p tr0
h3: finalTA tr0 a
h1: u a
followsT (singletonT u) tr0 tr0
move: {h2} tr0 a h3 h1.A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
forall (tr0 : trace) (a : A),
finalTA tr0 a ->
u a -> followsT (singletonT u) tr0 tr0 cofix CIH.A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
CIH: forall (tr0 : trace) (a : A),
finalTA tr0 a -> u a -> followsT (singletonT u) tr0 tr0
forall (tr0 : trace) (a : A),
finalTA tr0 a ->
u a -> followsT (singletonT u) tr0 tr0 move => tr0 a h0; invs h0 => h0.A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
CIH: forall (tr0 : trace) (a : A),
finalTA tr0 a -> u a -> followsT (singletonT u) tr0 tr0
a: A
h0: u a
followsT (singletonT u) (Tnil a) (Tnil a)
A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
CIH: forall (tr0 : trace) (a : A),
finalTA tr0 a -> u a -> followsT (singletonT u) tr0 tr0
a, a0: A
b: B
tr: trace
H: finalTA tr a
h0: u a
followsT (singletonT u) (Tcons a0 b tr)
  (Tcons a0 b tr)
-A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
CIH: forall (tr0 : trace) (a : A),
finalTA tr0 a -> u a -> followsT (singletonT u) tr0 tr0
a: A
h0: u a
followsT (singletonT u) (Tnil a) (Tnil a)
A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
CIH: forall (tr0 : trace) (a : A),
finalTA tr0 a -> u a -> followsT (singletonT u) tr0 tr0
a, a0: A
b: B
tr: trace
H: finalTA tr a
h0: u a
followsT (singletonT u) (Tcons a0 b tr)
  (Tcons a0 b tr) exact/followsT_nil/nil_singletonT.A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
CIH: forall (tr0 : trace) (a : A),
finalTA tr0 a -> u a -> followsT (singletonT u) tr0 tr0
a, a0: A
b: B
tr: trace
H: finalTA tr a
h0: u a
followsT (singletonT u) (Tcons a0 b tr)
  (Tcons a0 b tr)
-A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
CIH: forall (tr0 : trace) (a : A),
finalTA tr0 a -> u a -> followsT (singletonT u) tr0 tr0
a, a0: A
b: B
tr: trace
H: finalTA tr a
h0: u a
followsT (singletonT u) (Tcons a0 b tr)
  (Tcons a0 b tr) exact: followsT_delay _ _ (CIH _ _ H h0).
Qed.

Lemma LastA_IterA : forall v b p,
 LastA ([|v|] *** (IterT (p *** <<v;b>>))) ->> v.A, B: Type
forall (v : propA) (b : B) (p : propT),
LastA (([|v|]) *** IterT (p *** (<< v; b >>))) ->> v
Proof.A, B: Type
forall (v : propA) (b : B) (p : propT),
LastA (([|v|]) *** IterT (p *** (<< v; b >>))) ->> v
move => v b p a h0.A, B: Type
v: propA
b: B
p: propT
a: A
h0: LastA (([|v|]) *** IterT (p *** (<< v; b >>))) a
v a
have h1: p =>> TtT by [].A, B: Type
v: propA
b: B
p: propT
a: A
h0: LastA (([|v|]) *** IterT (p *** (<< v; b >>))) a
h1: p =>> TtT
v a
have h2 := LastA_cont (AppendT_cont_R (IterT_cont (AppendT_cont_L h1))) h0.A, B: Type
v: propA
b: B
p: propT
a: A
h0: LastA (([|v|]) *** IterT (p *** (<< v; b >>))) a
h1: p =>> TtT
h2: LastA (([|v|]) *** IterT (TtT *** (<< v; b >>)))
  a
v a
have := LastA_cont (@IterT_DupT v b) h2.A, B: Type
v: propA
b: B
p: propT
a: A
h0: LastA (([|v|]) *** IterT (p *** (<< v; b >>))) a
h1: p =>> TtT
h2: LastA (([|v|]) *** IterT (TtT *** (<< v; b >>)))
  a
LastA (TtT *** ([|v|])) a -> v a
exact: LastA_AppendA.
Qed.

Lemma IterT_LastA_DupT : forall v b,
 (<<v;b>> *** (IterT (TtT *** <<v;b>>))) =>> (TtT *** [|v|]).A, B: Type
forall (v : propA) (b : B),
((<< v; b >>) *** IterT (TtT *** (<< v; b >>))) =>>
TtT *** ([|v|])
Proof.A, B: Type
forall (v : propA) (b : B),
((<< v; b >>) *** IterT (TtT *** (<< v; b >>))) =>>
TtT *** ([|v|])
move => v b tr0 [tr1 [[a [h0 h2]] h1]].A, B: Type
v: propA
b: B
tr0, tr1: trace
a: A
h0: v a
h2: bisim tr1 (Tcons a b (Tnil a))
h1: followsT (iterT (ttT *+* dupT v b)) tr1 tr0
satisfyT (TtT *** ([|v|])) tr0
invs h2; invs H1; invs h1; invs H3 => /=.A, B: Type
v: propA
b: B
tr': trace
h0: v (hd tr')
H1: iterT (ttT *+* dupT v b) tr'
(ttT *+* singletonT v) (Tcons (hd tr') b tr')
exists (Tcons (hd tr') b tr').A, B: Type
v: propA
b: B
tr': trace
h0: v (hd tr')
H1: iterT (ttT *+* dupT v b) tr'
ttT (Tcons (hd tr') b tr') /\
followsT (singletonT v) (Tcons (hd tr') b tr')
  (Tcons (hd tr') b tr') split => //.A, B: Type
v: propA
b: B
tr': trace
h0: v (hd tr')
H1: iterT (ttT *+* dupT v b) tr'
followsT (singletonT v) (Tcons (hd tr') b tr')
  (Tcons (hd tr') b tr')
apply: followsT_delay => //.A, B: Type
v: propA
b: B
tr': trace
h0: v (hd tr')
H1: iterT (ttT *+* dupT v b) tr'
followsT (singletonT v) tr' tr'
move: tr' h0 H1.A, B: Type
v: propA
b: B
forall tr' : trace,
v (hd tr') ->
iterT (ttT *+* dupT v b) tr' ->
followsT (singletonT v) tr' tr' cofix CIH.A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') -> iterT (ttT *+* dupT v b) tr' -> followsT (singletonT v) tr' tr'
forall tr' : trace,
v (hd tr') ->
iterT (ttT *+* dupT v b) tr' ->
followsT (singletonT v) tr' tr' move => tr0 h0 h1; invs h1.A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') -> iterT (ttT *+* dupT v b) tr' -> followsT (singletonT v) tr' tr'
a: A
h0: v (hd (Tnil a))
followsT (singletonT v) (Tnil a) (Tnil a)
A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') -> iterT (ttT *+* dupT v b) tr' -> followsT (singletonT v) tr' tr'
tr0: trace
h0: v (hd tr0)
tr: trace
H: (ttT *+* dupT v b) tr
H0: followsT (iterT (ttT *+* dupT v b)) tr tr0
followsT (singletonT v) tr0 tr0
-A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') -> iterT (ttT *+* dupT v b) tr' -> followsT (singletonT v) tr' tr'
a: A
h0: v (hd (Tnil a))
followsT (singletonT v) (Tnil a) (Tnil a)
A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') -> iterT (ttT *+* dupT v b) tr' -> followsT (singletonT v) tr' tr'
tr0: trace
h0: v (hd tr0)
tr: trace
H: (ttT *+* dupT v b) tr
H0: followsT (iterT (ttT *+* dupT v b)) tr tr0
followsT (singletonT v) tr0 tr0 exact/followsT_nil/nil_singletonT.A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') -> iterT (ttT *+* dupT v b) tr' -> followsT (singletonT v) tr' tr'
tr0: trace
h0: v (hd tr0)
tr: trace
H: (ttT *+* dupT v b) tr
H0: followsT (iterT (ttT *+* dupT v b)) tr tr0
followsT (singletonT v) tr0 tr0
-A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') -> iterT (ttT *+* dupT v b) tr' -> followsT (singletonT v) tr' tr'
tr0: trace
h0: v (hd tr0)
tr: trace
H: (ttT *+* dupT v b) tr
H0: followsT (iterT (ttT *+* dupT v b)) tr tr0
followsT (singletonT v) tr0 tr0 move: {h0} H => [tr1 [_ h1]].A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') -> iterT (ttT *+* dupT v b) tr' -> followsT (singletonT v) tr' tr'
tr0, tr: trace
H0: followsT (iterT (ttT *+* dupT v b)) tr tr0
tr1: trace
h1: followsT (dupT v b) tr1 tr
followsT (singletonT v) tr0 tr0
  move: tr1 tr tr0 h1 H0.A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') -> iterT (ttT *+* dupT v b) tr' -> followsT (singletonT v) tr' tr'
forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0 cofix CIH0.A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') -> iterT (ttT *+* dupT v b) tr' -> followsT (singletonT v) tr' tr'
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0 move => tr0 tr1 tr2 h0 h1; invs h0.A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') -> iterT (ttT *+* dupT v b) tr' -> followsT (singletonT v) tr' tr'
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr1, tr2: trace
h1: followsT (iterT (ttT *+* dupT v b)) tr1 tr2
H0: dupT v b tr1
followsT (singletonT v) tr2 tr2
A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') ->
iterT (ttT *+* dupT v b) tr' ->
followsT (singletonT v) tr' tr'
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr2: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (ttT *+* dupT v b))
  (Tcons a b0 tr') tr2
H: followsT (dupT v b) tr tr'
followsT (singletonT v) tr2 tr2
  +A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') -> iterT (ttT *+* dupT v b) tr' -> followsT (singletonT v) tr' tr'
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr1, tr2: trace
h1: followsT (iterT (ttT *+* dupT v b)) tr1 tr2
H0: dupT v b tr1
followsT (singletonT v) tr2 tr2
A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') ->
iterT (ttT *+* dupT v b) tr' ->
followsT (singletonT v) tr' tr'
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr2: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (ttT *+* dupT v b))
  (Tcons a b0 tr') tr2
H: followsT (dupT v b) tr tr'
followsT (singletonT v) tr2 tr2 move: H0 => [a [h0 h2]].A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') -> iterT (ttT *+* dupT v b) tr' -> followsT (singletonT v) tr' tr'
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr1, tr2: trace
h1: followsT (iterT (ttT *+* dupT v b)) tr1 tr2
a: A
h0: v a
h2: bisim tr1 (Tcons a b (Tnil a))
followsT (singletonT v) tr2 tr2
A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') ->
iterT (ttT *+* dupT v b) tr' ->
followsT (singletonT v) tr' tr'
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr2: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (ttT *+* dupT v b))
  (Tcons a b0 tr') tr2
H: followsT (dupT v b) tr tr'
followsT (singletonT v) tr2 tr2
    invs h2; invs H1; invs h1; invs H3.A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') -> iterT (ttT *+* dupT v b) tr' -> followsT (singletonT v) tr' tr'
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr': trace
h0: v (hd tr')
H1: iterT (ttT *+* dupT v b) tr'
followsT (singletonT v) (Tcons (hd tr') b tr')
  (Tcons (hd tr') b tr')
A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') ->
iterT (ttT *+* dupT v b) tr' ->
followsT (singletonT v) tr' tr'
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr2: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (ttT *+* dupT v b))
  (Tcons a b0 tr') tr2
H: followsT (dupT v b) tr tr'
followsT (singletonT v) tr2 tr2
    exact/followsT_delay/CIH.A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') -> iterT (ttT *+* dupT v b) tr' -> followsT (singletonT v) tr' tr'
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr2: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (ttT *+* dupT v b))
  (Tcons a b0 tr') tr2
H: followsT (dupT v b) tr tr'
followsT (singletonT v) tr2 tr2
  +A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') -> iterT (ttT *+* dupT v b) tr' -> followsT (singletonT v) tr' tr'
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
tr2: trace
a: A
b0: B
tr, tr': trace
h1: followsT (iterT (ttT *+* dupT v b))
  (Tcons a b0 tr') tr2
H: followsT (dupT v b) tr tr'
followsT (singletonT v) tr2 tr2 invs h1.A, B: Type
v: propA
b: B
CIH: forall tr' : trace,
v (hd tr') -> iterT (ttT *+* dupT v b) tr' -> followsT (singletonT v) tr' tr'
CIH0: forall tr1 tr tr0 : trace,
followsT (dupT v b) tr1 tr ->
followsT (iterT (ttT *+* dupT v b)) tr tr0 ->
followsT (singletonT v) tr0 tr0
a: A
b0: B
tr, tr', tr'0: trace
H: followsT (dupT v b) tr tr'
H4: followsT (iterT (ttT *+* dupT v b)) tr' tr'0
followsT (singletonT v) (Tcons a b0 tr'0)
  (Tcons a b0 tr'0) exact: followsT_delay _ _ (CIH0 _ _ _ H H4).
Qed.

Lemma LastA_LastA : forall p q,
 (LastA ([|LastA p|] *** q)) ->> (LastA (p *** q)).A, B: Type
forall p q : propT,
LastA (([|LastA p|]) *** q) ->> LastA (p *** q)
Proof.A, B: Type
forall p q : propT,
LastA (([|LastA p|]) *** q) ->> LastA (p *** q)
move => [p hp] [q hq] a /= [tr1 [[tr0 [[tr2 [h0 h3]] h2]] h1]]; invs h3; invs h2.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h0: lastA p (hd tr1)
h1: finalTA tr1 a
H1: q tr1
lastA (p *+* q) a
move: h0 => [tr2 [h0 h2]].A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
lastA (p *+* q) a
exists (tr2 +++ tr1).A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
(p *+* q) (tr2 +++ tr1) /\ finalTA (tr2 +++ tr1) a split.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
(p *+* q) (tr2 +++ tr1)
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
finalTA (tr2 +++ tr1) a
-A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
(p *+* q) (tr2 +++ tr1)
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
finalTA (tr2 +++ tr1) a exists tr2.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
p tr2 /\ followsT q tr2 (tr2 +++ tr1)
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
finalTA (tr2 +++ tr1) a split => //.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
followsT q tr2 (tr2 +++ tr1)
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
finalTA (tr2 +++ tr1) a
  move: {h0 h1} tr2 h2.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
H1: q tr1
forall tr2 : trace,
finalTA tr2 (hd tr1) -> followsT q tr2 (tr2 +++ tr1)
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
finalTA (tr2 +++ tr1) a cofix CIH.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
H1: q tr1
CIH: forall tr2 : trace, finalTA tr2 (hd tr1) -> followsT q tr2 (tr2 +++ tr1)
forall tr2 : trace,
finalTA tr2 (hd tr1) -> followsT q tr2 (tr2 +++ tr1)
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
finalTA (tr2 +++ tr1) a
  case => [a0 | a0 b tr0] h0.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
H1: q tr1
CIH: forall tr2 : trace, finalTA tr2 (hd tr1) -> followsT q tr2 (tr2 +++ tr1)
a0: A
h0: finalTA (Tnil a0) (hd tr1)
followsT q (Tnil a0) (Tnil a0 +++ tr1)
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
H1: q tr1
CIH: forall tr2 : trace, finalTA tr2 (hd tr1) -> followsT q tr2 (tr2 +++ tr1)
a0: A
b: B
tr0: trace
h0: finalTA (Tcons a0 b tr0) (hd tr1)
followsT q (Tcons a0 b tr0) (Tcons a0 b tr0 +++ tr1)
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
finalTA (tr2 +++ tr1) a
  +A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
H1: q tr1
CIH: forall tr2 : trace, finalTA tr2 (hd tr1) -> followsT q tr2 (tr2 +++ tr1)
a0: A
h0: finalTA (Tnil a0) (hd tr1)
followsT q (Tnil a0) (Tnil a0 +++ tr1)
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
H1: q tr1
CIH: forall tr2 : trace, finalTA tr2 (hd tr1) -> followsT q tr2 (tr2 +++ tr1)
a0: A
b: B
tr0: trace
h0: finalTA (Tcons a0 b tr0) (hd tr1)
followsT q (Tcons a0 b tr0) (Tcons a0 b tr0 +++ tr1)
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
finalTA (tr2 +++ tr1) a rewrite trace_append_nil.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
H1: q tr1
CIH: forall tr2 : trace, finalTA tr2 (hd tr1) -> followsT q tr2 (tr2 +++ tr1)
a0: A
h0: finalTA (Tnil a0) (hd tr1)
followsT q (Tnil a0) tr1
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
H1: q tr1
CIH: forall tr2 : trace, finalTA tr2 (hd tr1) -> followsT q tr2 (tr2 +++ tr1)
a0: A
b: B
tr0: trace
h0: finalTA (Tcons a0 b tr0) (hd tr1)
followsT q (Tcons a0 b tr0) (Tcons a0 b tr0 +++ tr1)
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
finalTA (tr2 +++ tr1) a apply: followsT_nil => //.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
H1: q tr1
CIH: forall tr2 : trace, finalTA tr2 (hd tr1) -> followsT q tr2 (tr2 +++ tr1)
a0: A
h0: finalTA (Tnil a0) (hd tr1)
hd tr1 = a0
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
H1: q tr1
CIH: forall tr2 : trace, finalTA tr2 (hd tr1) -> followsT q tr2 (tr2 +++ tr1)
a0: A
b: B
tr0: trace
h0: finalTA (Tcons a0 b tr0) (hd tr1)
followsT q (Tcons a0 b tr0) (Tcons a0 b tr0 +++ tr1)
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
finalTA (tr2 +++ tr1) a by invs h0.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
H1: q tr1
CIH: forall tr2 : trace, finalTA tr2 (hd tr1) -> followsT q tr2 (tr2 +++ tr1)
a0: A
b: B
tr0: trace
h0: finalTA (Tcons a0 b tr0) (hd tr1)
followsT q (Tcons a0 b tr0) (Tcons a0 b tr0 +++ tr1)
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
finalTA (tr2 +++ tr1) a
  +A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
H1: q tr1
CIH: forall tr2 : trace, finalTA tr2 (hd tr1) -> followsT q tr2 (tr2 +++ tr1)
a0: A
b: B
tr0: trace
h0: finalTA (Tcons a0 b tr0) (hd tr1)
followsT q (Tcons a0 b tr0) (Tcons a0 b tr0 +++ tr1)
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
finalTA (tr2 +++ tr1) a invs h0.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
H1: q tr1
CIH: forall tr2 : trace, finalTA tr2 (hd tr1) -> followsT q tr2 (tr2 +++ tr1)
a0: A
b: B
tr0: trace
H4: finalTA tr0 (hd tr1)
followsT q (Tcons a0 b tr0) (Tcons a0 b tr0 +++ tr1)
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
finalTA (tr2 +++ tr1) a rewrite trace_append_cons.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
H1: q tr1
CIH: forall tr2 : trace, finalTA tr2 (hd tr1) -> followsT q tr2 (tr2 +++ tr1)
a0: A
b: B
tr0: trace
H4: finalTA tr0 (hd tr1)
followsT q (Tcons a0 b tr0) (Tcons a0 b (tr0 +++ tr1))
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
finalTA (tr2 +++ tr1) a
    exact/followsT_delay/CIH.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
finalTA (tr2 +++ tr1) a
-A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
H1: q tr1
tr2: trace
h0: p tr2
h2: finalTA tr2 (hd tr1)
finalTA (tr2 +++ tr1) a move => {H1 h0}; move h0: (hd tr1) h2 => a0 h2.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a: A
tr1: trace
h1: finalTA tr1 a
tr2: trace
a0: A
h0: hd tr1 = a0
h2: finalTA tr2 a0
finalTA (tr2 +++ tr1) a
  move: h2 tr1 h0 h1; elim => {tr2 a0} [a0 | a0 b a1 tr2 Hfinal IH] tr0 h0 h1.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a, a0: A
tr0: trace
h0: hd tr0 = a0
h1: finalTA tr0 a
finalTA (Tnil a0 +++ tr0) a
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a, a0: A
b: B
a1: A
tr2: trace
Hfinal: finalTA tr2 a1
IH: forall tr1 : trace,
hd tr1 = a1 ->
finalTA tr1 a -> finalTA (tr2 +++ tr1) a
tr0: trace
h0: hd tr0 = a1
h1: finalTA tr0 a
finalTA (Tcons a0 b tr2 +++ tr0) a
  +A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a, a0: A
tr0: trace
h0: hd tr0 = a0
h1: finalTA tr0 a
finalTA (Tnil a0 +++ tr0) a
A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a, a0: A
b: B
a1: A
tr2: trace
Hfinal: finalTA tr2 a1
IH: forall tr1 : trace,
hd tr1 = a1 ->
finalTA tr1 a -> finalTA (tr2 +++ tr1) a
tr0: trace
h0: hd tr0 = a1
h1: finalTA tr0 a
finalTA (Tcons a0 b tr2 +++ tr0) a by rewrite trace_append_nil.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a, a0: A
b: B
a1: A
tr2: trace
Hfinal: finalTA tr2 a1
IH: forall tr1 : trace,
hd tr1 = a1 ->
finalTA tr1 a -> finalTA (tr2 +++ tr1) a
tr0: trace
h0: hd tr0 = a1
h1: finalTA tr0 a
finalTA (Tcons a0 b tr2 +++ tr0) a
  +A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a, a0: A
b: B
a1: A
tr2: trace
Hfinal: finalTA tr2 a1
IH: forall tr1 : trace,
hd tr1 = a1 ->
finalTA tr1 a -> finalTA (tr2 +++ tr1) a
tr0: trace
h0: hd tr0 = a1
h1: finalTA tr0 a
finalTA (Tcons a0 b tr2 +++ tr0) a rewrite trace_append_cons.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a, a0: A
b: B
a1: A
tr2: trace
Hfinal: finalTA tr2 a1
IH: forall tr1 : trace,
hd tr1 = a1 ->
finalTA tr1 a -> finalTA (tr2 +++ tr1) a
tr0: trace
h0: hd tr0 = a1
h1: finalTA tr0 a
finalTA (Tcons a0 b (tr2 +++ tr0)) a
    apply: finalTA_delay.A, B: Type
p: trace -> Prop
hp: setoidT p
q: trace -> Prop
hq: setoidT q
a, a0: A
b: B
a1: A
tr2: trace
Hfinal: finalTA tr2 a1
IH: forall tr1 : trace,
hd tr1 = a1 ->
finalTA tr1 a -> finalTA (tr2 +++ tr1) a
tr0: trace
h0: hd tr0 = a1
h1: finalTA tr0 a
finalTA (tr2 +++ tr0) a
    exact: IH _ h0 h1.
Qed.

Lemma SingletonT_andA_AppendT : forall u v,
 (v andA u) ->> LastA ([|v|] *** [|u|]).A, B: Type
forall u v : propA,
(v andA u) ->> LastA (([|v|]) *** ([|u|]))
Proof.A, B: Type
forall u v : propA,
(v andA u) ->> LastA (([|v|]) *** ([|u|]))
move => u v a [h0 h1].A, B: Type
u, v: propA
a: A
h0: v a
h1: u a
LastA (([|v|]) *** ([|u|])) a
exists (Tnil a); split; last by apply: finalTA_nil.A, B: Type
u, v: propA
a: A
h0: v a
h1: u a
(singletonT v *+* singletonT u) (Tnil a)
exists (Tnil a); split; first by apply: nil_singletonT.A, B: Type
u, v: propA
a: A
h0: v a
h1: u a
followsT (singletonT u) (Tnil a) (Tnil a)
exact/followsT_nil/nil_singletonT.
Qed.

CoFixpoint lastdup (tr : trace) (b : B) : trace :=
match tr with
| Tnil a => Tcons a b (Tnil a)
| Tcons a b' tr' => Tcons a b' (lastdup tr' b)
end.

Lemma lastdup_hd : forall tr b, hd tr = hd (lastdup tr b).A, B: Type
forall (tr : trace) (b : B), hd tr = hd (lastdup tr b)
Proof.A, B: Type
forall (tr : trace) (b : B), hd tr = hd (lastdup tr b)
by case => [a b | a b tr b0]; rewrite [lastdup _ _]trace_destr.
Qed.

Lemma followsT_dupT : forall u tr b,
 followsT (singletonT u) tr tr ->
 followsT (dupT u b) tr (lastdup tr b).A, B: Type
forall (u : propA) (tr : trace) (b : B),
followsT (singletonT u) tr tr ->
followsT (dupT u b) tr (lastdup tr b)
Proof.A, B: Type
forall (u : propA) (tr : trace) (b : B),
followsT (singletonT u) tr tr ->
followsT (dupT u b) tr (lastdup tr b)
cofix CIH.A, B: Type
CIH: forall (u : propA) (tr : trace) (b : B),
followsT (singletonT u) tr tr -> followsT (dupT u b) tr (lastdup tr b)
forall (u : propA) (tr : trace) (b : B),
followsT (singletonT u) tr tr ->
followsT (dupT u b) tr (lastdup tr b) move => u tr0 b h0; invs h0.A, B: Type
CIH: forall (u : propA) (tr : trace) (b : B),
followsT (singletonT u) tr tr -> followsT (dupT u b) tr (lastdup tr b)
u: propA
b: B
a: A
H: hd (Tnil a) = a
H0: singletonT u (Tnil a)
followsT (dupT u b) (Tnil a) (lastdup (Tnil a) b)
A, B: Type
CIH: forall (u : propA) (tr : trace) (b : B),
followsT (singletonT u) tr tr -> followsT (dupT u b) tr (lastdup tr b)
u: propA
b: B
a: A
b0: B
tr: trace
H1: followsT (singletonT u) tr tr
followsT (dupT u b) (Tcons a b0 tr)
  (lastdup (Tcons a b0 tr) b)
-A, B: Type
CIH: forall (u : propA) (tr : trace) (b : B),
followsT (singletonT u) tr tr -> followsT (dupT u b) tr (lastdup tr b)
u: propA
b: B
a: A
H: hd (Tnil a) = a
H0: singletonT u (Tnil a)
followsT (dupT u b) (Tnil a) (lastdup (Tnil a) b)
A, B: Type
CIH: forall (u : propA) (tr : trace) (b : B),
followsT (singletonT u) tr tr -> followsT (dupT u b) tr (lastdup tr b)
u: propA
b: B
a: A
b0: B
tr: trace
H1: followsT (singletonT u) tr tr
followsT (dupT u b) (Tcons a b0 tr)
  (lastdup (Tcons a b0 tr) b) rewrite [lastdup _ _]trace_destr /=.A, B: Type
CIH: forall (u : propA) (tr : trace) (b : B),
followsT (singletonT u) tr tr -> followsT (dupT u b) tr (lastdup tr b)
u: propA
b: B
a: A
H: hd (Tnil a) = a
H0: singletonT u (Tnil a)
followsT (dupT u b) (Tnil a) (Tcons a b (Tnil a))
A, B: Type
CIH: forall (u : propA) (tr : trace) (b : B),
followsT (singletonT u) tr tr -> followsT (dupT u b) tr (lastdup tr b)
u: propA
b: B
a: A
b0: B
tr: trace
H1: followsT (singletonT u) tr tr
followsT (dupT u b) (Tcons a b0 tr)
  (lastdup (Tcons a b0 tr) b)
  move: H0 => [a0 [h0 h1]]; invs h1.A, B: Type
CIH: forall (u : propA) (tr : trace) (b : B),
followsT (singletonT u) tr tr -> followsT (dupT u b) tr (lastdup tr b)
u: propA
b: B
a0: A
H: hd (Tnil a0) = a0
h0: u a0
followsT (dupT u b) (Tnil a0) (Tcons a0 b (Tnil a0))
A, B: Type
CIH: forall (u : propA) (tr : trace) (b : B),
followsT (singletonT u) tr tr -> followsT (dupT u b) tr (lastdup tr b)
u: propA
b: B
a: A
b0: B
tr: trace
H1: followsT (singletonT u) tr tr
followsT (dupT u b) (Tcons a b0 tr)
  (lastdup (Tcons a b0 tr) b)
  apply: followsT_nil => //.A, B: Type
CIH: forall (u : propA) (tr : trace) (b : B),
followsT (singletonT u) tr tr -> followsT (dupT u b) tr (lastdup tr b)
u: propA
b: B
a0: A
H: hd (Tnil a0) = a0
h0: u a0
dupT u b (Tcons a0 b (Tnil a0))
A, B: Type
CIH: forall (u : propA) (tr : trace) (b : B),
followsT (singletonT u) tr tr -> followsT (dupT u b) tr (lastdup tr b)
u: propA
b: B
a: A
b0: B
tr: trace
H1: followsT (singletonT u) tr tr
followsT (dupT u b) (Tcons a b0 tr)
  (lastdup (Tcons a b0 tr) b)
  exact: dupT_Tcons.A, B: Type
CIH: forall (u : propA) (tr : trace) (b : B),
followsT (singletonT u) tr tr -> followsT (dupT u b) tr (lastdup tr b)
u: propA
b: B
a: A
b0: B
tr: trace
H1: followsT (singletonT u) tr tr
followsT (dupT u b) (Tcons a b0 tr)
  (lastdup (Tcons a b0 tr) b)
-A, B: Type
CIH: forall (u : propA) (tr : trace) (b : B),
followsT (singletonT u) tr tr -> followsT (dupT u b) tr (lastdup tr b)
u: propA
b: B
a: A
b0: B
tr: trace
H1: followsT (singletonT u) tr tr
followsT (dupT u b) (Tcons a b0 tr)
  (lastdup (Tcons a b0 tr) b) rewrite [lastdup _ _]trace_destr /=.A, B: Type
CIH: forall (u : propA) (tr : trace) (b : B),
followsT (singletonT u) tr tr -> followsT (dupT u b) tr (lastdup tr b)
u: propA
b: B
a: A
b0: B
tr: trace
H1: followsT (singletonT u) tr tr
followsT (dupT u b) (Tcons a b0 tr)
  (Tcons a b0 (lastdup tr b))
  exact/followsT_delay/CIH.
Qed.

Lemma finalTA_lastdup : forall tr a b,
 finalTA tr a -> finalTA (lastdup tr b) a.A, B: Type
forall (tr : trace) (a : A) (b : B),
finalTA tr a -> finalTA (lastdup tr b) a
Proof.A, B: Type
forall (tr : trace) (a : A) (b : B),
finalTA tr a -> finalTA (lastdup tr b) a
move => tr a b1; elim => {tr a} [a | a1 b2 a2 tr Hfinal IH].A, B: Type
b1: B
a: A
finalTA (lastdup (Tnil a) b1) a
A, B: Type
b1: B
a1: A
b2: B
a2: A
tr: trace
Hfinal: finalTA tr a2
IH: finalTA (lastdup tr b1) a2
finalTA (lastdup (Tcons a1 b2 tr) b1) a2
-A, B: Type
b1: B
a: A
finalTA (lastdup (Tnil a) b1) a
A, B: Type
b1: B
a1: A
b2: B
a2: A
tr: trace
Hfinal: finalTA tr a2
IH: finalTA (lastdup tr b1) a2
finalTA (lastdup (Tcons a1 b2 tr) b1) a2 rewrite [lastdup _ _]trace_destr /=.A, B: Type
b1: B
a: A
finalTA (Tcons a b1 (Tnil a)) a
A, B: Type
b1: B
a1: A
b2: B
a2: A
tr: trace
Hfinal: finalTA tr a2
IH: finalTA (lastdup tr b1) a2
finalTA (lastdup (Tcons a1 b2 tr) b1) a2
  apply: finalTA_delay.A, B: Type
b1: B
a: A
finalTA (Tnil a) a
A, B: Type
b1: B
a1: A
b2: B
a2: A
tr: trace
Hfinal: finalTA tr a2
IH: finalTA (lastdup tr b1) a2
finalTA (lastdup (Tcons a1 b2 tr) b1) a2 exact: finalTA_nil.A, B: Type
b1: B
a1: A
b2: B
a2: A
tr: trace
Hfinal: finalTA tr a2
IH: finalTA (lastdup tr b1) a2
finalTA (lastdup (Tcons a1 b2 tr) b1) a2
-A, B: Type
b1: B
a1: A
b2: B
a2: A
tr: trace
Hfinal: finalTA tr a2
IH: finalTA (lastdup tr b1) a2
finalTA (lastdup (Tcons a1 b2 tr) b1) a2 rewrite [lastdup _ _]trace_destr /=.A, B: Type
b1: B
a1: A
b2: B
a2: A
tr: trace
Hfinal: finalTA tr a2
IH: finalTA (lastdup tr b1) a2
finalTA (Tcons a1 b2 (lastdup tr b1)) a2
  exact: finalTA_delay.
Qed.

Lemma LastA_DupT : forall p u b,
 LastA (p *** [|u|]) ->> LastA (p *** <<u;b>>).A, B: Type
forall (p : propT) (u : propA) (b : B),
LastA (p *** ([|u|])) ->> LastA (p *** (<< u; b >>))
Proof.A, B: Type
forall (p : propT) (u : propA) (b : B),
LastA (p *** ([|u|])) ->> LastA (p *** (<< u; b >>))
move => [p hp] u b a [tr0 [[tr1 [h0 h2]] h1]].A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
b: B
a: A
tr0, tr1: trace
h0: p tr1
h2: followsT (singletonT u) tr1 tr0
h1: finalTA tr0 a
LastA
  (exist (fun p : trace -> Prop => setoidT p) p hp ***
   (<< u; b >>)) a
exists (lastdup tr0 b); split; last by apply: finalTA_lastdup.A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
b: B
a: A
tr0, tr1: trace
h0: p tr1
h2: followsT (singletonT u) tr1 tr0
h1: finalTA tr0 a
(p *+* dupT u b) (lastdup tr0 b)
have h3 := followsT_singletonT h2.A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
b: B
a: A
tr0, tr1: trace
h0: p tr1
h2: followsT (singletonT u) tr1 tr0
h1: finalTA tr0 a
h3: bisim tr1 tr0
(p *+* dupT u b) (lastdup tr0 b)
exists tr0; split.A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
b: B
a: A
tr0, tr1: trace
h0: p tr1
h2: followsT (singletonT u) tr1 tr0
h1: finalTA tr0 a
h3: bisim tr1 tr0
p tr0
A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
b: B
a: A
tr0, tr1: trace
h0: p tr1
h2: followsT (singletonT u) tr1 tr0
h1: finalTA tr0 a
h3: bisim tr1 tr0
followsT (dupT u b) tr0 (lastdup tr0 b)
-A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
b: B
a: A
tr0, tr1: trace
h0: p tr1
h2: followsT (singletonT u) tr1 tr0
h1: finalTA tr0 a
h3: bisim tr1 tr0
p tr0
A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
b: B
a: A
tr0, tr1: trace
h0: p tr1
h2: followsT (singletonT u) tr1 tr0
h1: finalTA tr0 a
h3: bisim tr1 tr0
followsT (dupT u b) tr0 (lastdup tr0 b) exact: hp _ h0 _ h3.A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
b: B
a: A
tr0, tr1: trace
h0: p tr1
h2: followsT (singletonT u) tr1 tr0
h1: finalTA tr0 a
h3: bisim tr1 tr0
followsT (dupT u b) tr0 (lastdup tr0 b)
-A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
b: B
a: A
tr0, tr1: trace
h0: p tr1
h2: followsT (singletonT u) tr1 tr0
h1: finalTA tr0 a
h3: bisim tr1 tr0
followsT (dupT u b) tr0 (lastdup tr0 b) have h4 := followsT_setoidT (@singletonT_setoidT _) h2 h3 (bisim_refl _) => {h2}.A, B: Type
p: trace -> Prop
hp: setoidT p
u: propA
b: B
a: A
tr0, tr1: trace
h0: p tr1
h1: finalTA tr0 a
h3: bisim tr1 tr0
h4: followsT (singletonT u) tr0 tr0
followsT (dupT u b) tr0 (lastdup tr0 b)
  exact: followsT_dupT b h4.
Qed.

Midpoint property

This property identifies a trace that is both a suffix of tr0 and a prefix of tr1, and is the stepping stone to showing the right associativity of the append property.

CoInductive midpointT
  (p0 p1 : trace -> Prop) (tr0 tr1 : trace) (h : followsT (appendT p0 p1) tr0 tr1)
  : trace -> Prop :=
| midpointT_nil : forall tr,
   tr0 = Tnil (hd tr1) ->
   p0 tr ->
   followsT p1 tr tr1 ->
   midpointT h tr
| midpointT_delay : forall tr2 tr3 (h1 : followsT (appendT p0 p1) tr2 tr3) (a : A) (b : B) tr',
   tr0 = Tcons a b tr2 ->
   tr1 = Tcons a b tr3 ->
   @midpointT p0 p1 tr2 tr3 h1 tr' ->
   midpointT h (Tcons a b tr').

Lemma midpointT_before : forall p0 p1 tr0 tr1 (h : followsT (appendT p0 p1) tr0 tr1) tr',
 midpointT h tr' -> followsT p0 tr0 tr'.A, B: Type
forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
  (h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr'
Proof.A, B: Type
forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
  (h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr'
cofix CIH.A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr'
forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
  (h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr' dependent inversion h; subst.A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr'
p0, p1: trace -> Prop
tr1: trace
h: followsT (p0 *+* p1) (Tnil (hd tr1)) tr1
a0: (p0 *+* p1) tr1
forall tr' : trace,
midpointT (followsT_nil eq_refl a0) tr' ->
followsT p0 (Tnil (hd tr1)) tr'
A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr'
p0, p1: trace -> Prop
a: A
b: B
tr, tr': trace
h: followsT (p0 *+* p1) (Tcons a b tr)
  (Tcons a b tr')
f: followsT (p0 *+* p1) tr tr'
forall tr'0 : trace,
midpointT (followsT_delay a b f) tr'0 ->
followsT p0 (Tcons a b tr) tr'0
-A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr'
p0, p1: trace -> Prop
tr1: trace
h: followsT (p0 *+* p1) (Tnil (hd tr1)) tr1
a0: (p0 *+* p1) tr1
forall tr' : trace,
midpointT (followsT_nil eq_refl a0) tr' ->
followsT p0 (Tnil (hd tr1)) tr'
A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr'
p0, p1: trace -> Prop
a: A
b: B
tr, tr': trace
h: followsT (p0 *+* p1) (Tcons a b tr)
  (Tcons a b tr')
f: followsT (p0 *+* p1) tr tr'
forall tr'0 : trace,
midpointT (followsT_delay a b f) tr'0 ->
followsT p0 (Tcons a b tr) tr'0 move => tr' hm.A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr'
p0, p1: trace -> Prop
tr1: trace
h: followsT (p0 *+* p1) (Tnil (hd tr1)) tr1
a0: (p0 *+* p1) tr1
tr': trace
hm: midpointT (followsT_nil eq_refl a0) tr'
followsT p0 (Tnil (hd tr1)) tr'
A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr'
p0, p1: trace -> Prop
a: A
b: B
tr, tr': trace
h: followsT (p0 *+* p1) (Tcons a b tr)
  (Tcons a b tr')
f: followsT (p0 *+* p1) tr tr'
forall tr'0 : trace,
midpointT (followsT_delay a b f) tr'0 ->
followsT p0 (Tcons a b tr) tr'0
  invs hm; invs H; invs a0; invs H; invs h.A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr'
p0, p1: trace -> Prop
tr1, tr': trace
H0: p0 tr'
H1: followsT p1 tr' tr1
x: trace
H2: p0 x
H3: followsT p1 x tr1
H4: hd tr1 = hd tr1
H5: (p0 *+* p1) tr1
followsT p0 (Tnil (hd tr1)) tr'
A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr'
p0, p1: trace -> Prop
a: A
b: B
tr, tr': trace
h: followsT (p0 *+* p1) (Tcons a b tr)
  (Tcons a b tr')
f: followsT (p0 *+* p1) tr tr'
forall tr'0 : trace,
midpointT (followsT_delay a b f) tr'0 ->
followsT p0 (Tcons a b tr) tr'0
  apply: followsT_nil => //.A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr'
p0, p1: trace -> Prop
tr1, tr': trace
H0: p0 tr'
H1: followsT p1 tr' tr1
x: trace
H2: p0 x
H3: followsT p1 x tr1
H4: hd tr1 = hd tr1
H5: (p0 *+* p1) tr1
hd tr' = hd tr1
A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr'
p0, p1: trace -> Prop
a: A
b: B
tr, tr': trace
h: followsT (p0 *+* p1) (Tcons a b tr)
  (Tcons a b tr')
f: followsT (p0 *+* p1) tr tr'
forall tr'0 : trace,
midpointT (followsT_delay a b f) tr'0 ->
followsT p0 (Tcons a b tr) tr'0
  by inversion H1.A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr'
p0, p1: trace -> Prop
a: A
b: B
tr, tr': trace
h: followsT (p0 *+* p1) (Tcons a b tr)
  (Tcons a b tr')
f: followsT (p0 *+* p1) tr tr'
forall tr'0 : trace,
midpointT (followsT_delay a b f) tr'0 ->
followsT p0 (Tcons a b tr) tr'0
-A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr'
p0, p1: trace -> Prop
a: A
b: B
tr, tr': trace
h: followsT (p0 *+* p1) (Tcons a b tr)
  (Tcons a b tr')
f: followsT (p0 *+* p1) tr tr'
forall tr'0 : trace,
midpointT (followsT_delay a b f) tr'0 ->
followsT p0 (Tcons a b tr) tr'0 subst; move => [a0 | a0 b0 tr0] hm; first by inversion hm.A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr'
p0, p1: trace -> Prop
a: A
b: B
tr, tr': trace
h: followsT (p0 *+* p1) (Tcons a b tr)
  (Tcons a b tr')
f: followsT (p0 *+* p1) tr tr'
a0: A
b0: B
tr0: trace
hm: midpointT (followsT_delay a b f)
  (Tcons a0 b0 tr0)
followsT p0 (Tcons a b tr) (Tcons a0 b0 tr0)
  invs hm; try invs H; invs H2; invs H3.A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p0 tr0 tr'
p0, p1: trace -> Prop
a0: A
b0: B
tr2, tr3: trace
h: followsT (p0 *+* p1) (Tcons a0 b0 tr2)
  (Tcons a0 b0 tr3)
f: followsT (p0 *+* p1) tr2 tr3
tr0: trace
h1: followsT (p0 *+* p1) tr2 tr3
H4: midpointT h1 tr0
followsT p0 (Tcons a0 b0 tr2) (Tcons a0 b0 tr0)
  exact: followsT_delay _ _ (CIH _ _ _ _ h1 _ _).
Qed.

Lemma midpointT_after : forall p0 p1 tr0 tr1 (h : followsT (appendT p0 p1) tr0 tr1) tr',
 midpointT h tr' -> followsT p1 tr' tr1.A, B: Type
forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
  (h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p1 tr' tr1
Proof.A, B: Type
forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
  (h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p1 tr' tr1
cofix CIH.A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p1 tr' tr1
forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
  (h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p1 tr' tr1 dependent inversion h; subst => tr0 hm.A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p1 tr' tr1
p0, p1: trace -> Prop
tr1: trace
h: followsT (p0 *+* p1) (Tnil (hd tr1)) tr1
a0: (p0 *+* p1) tr1
tr0: trace
hm: midpointT (followsT_nil eq_refl a0) tr0
followsT p1 tr0 tr1
A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p1 tr' tr1
p0, p1: trace -> Prop
a: A
b: B
tr, tr': trace
h: followsT (p0 *+* p1) (Tcons a b tr)
  (Tcons a b tr')
f: followsT (p0 *+* p1) tr tr'
tr0: trace
hm: midpointT (followsT_delay a b f) tr0
followsT p1 tr0 (Tcons a b tr')
-A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p1 tr' tr1
p0, p1: trace -> Prop
tr1: trace
h: followsT (p0 *+* p1) (Tnil (hd tr1)) tr1
a0: (p0 *+* p1) tr1
tr0: trace
hm: midpointT (followsT_nil eq_refl a0) tr0
followsT p1 tr0 tr1
A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p1 tr' tr1
p0, p1: trace -> Prop
a: A
b: B
tr, tr': trace
h: followsT (p0 *+* p1) (Tcons a b tr)
  (Tcons a b tr')
f: followsT (p0 *+* p1) tr tr'
tr0: trace
hm: midpointT (followsT_delay a b f) tr0
followsT p1 tr0 (Tcons a b tr') by invs hm; invs h.A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p1 tr' tr1
p0, p1: trace -> Prop
a: A
b: B
tr, tr': trace
h: followsT (p0 *+* p1) (Tcons a b tr)
  (Tcons a b tr')
f: followsT (p0 *+* p1) tr tr'
tr0: trace
hm: midpointT (followsT_delay a b f) tr0
followsT p1 tr0 (Tcons a b tr')
-A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p1 tr' tr1
p0, p1: trace -> Prop
a: A
b: B
tr, tr': trace
h: followsT (p0 *+* p1) (Tcons a b tr)
  (Tcons a b tr')
f: followsT (p0 *+* p1) tr tr'
tr0: trace
hm: midpointT (followsT_delay a b f) tr0
followsT p1 tr0 (Tcons a b tr') invs hm; invs H; invs H0.A, B: Type
CIH: forall (p0 p1 : trace -> Prop) (tr0 tr1 : trace)
(h : followsT (p0 *+* p1) tr0 tr1) (tr' : trace),
midpointT h tr' -> followsT p1 tr' tr1
p0, p1: trace -> Prop
a0: A
b0: B
tr2, tr3: trace
h: followsT (p0 *+* p1) (Tcons a0 b0 tr2)
  (Tcons a0 b0 tr3)
f: followsT (p0 *+* p1) tr2 tr3
tr'0: trace
h1: followsT (p0 *+* p1) tr2 tr3
H1: midpointT h1 tr'0
followsT p1 (Tcons a0 b0 tr'0) (Tcons a0 b0 tr3)
  exact: followsT_delay _ _ (CIH _ _ _ _ h1 _ _).
Qed.

End sec_trace_properties.

Trace property operators and notations

Infix "andT" := AndT (at level 60, right associativity).Identifier 'andT' now a keyword
Infix "orT" := OrT (at level 60, right associativity).Identifier 'orT' now a keyword
Infix "=>>" := propT_imp (at level 60, right associativity).
Infix "->>" := propA_imp (at level 60, right associativity).
Infix "andA" := andA (at level 60, right associativity).Identifier 'andA' now a keyword
Notation "[| p |]" := (@SingletonT _ _ p) (at level 80).
Infix "*+*" := appendT (at level 60, right associativity).
Infix "***" := AppendT (at level 60, right associativity).
Notation "<< p ; b >>" := (@DupT _ _ p b) (at level 80).