url stringclasses 147
values | commit stringclasses 147
values | file_path stringlengths 7 101 | full_name stringlengths 1 94 | start stringlengths 6 10 | end stringlengths 6 11 | tactic stringlengths 1 11.2k | state_before stringlengths 3 2.09M | state_after stringlengths 6 2.09M |
|---|---|---|---|---|---|---|---|---|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | intro x | case hβ.Pure.refl
C : _root_.Container
R : Type uβ
x y : R
β’ β (i : Container.B (Container C R) (A.Pure x)),
eq (PEmpty.rec (fun x => M (Container C R)) i) (PEmpty.rec (fun x => M (Container C R)) i) | case hβ.Pure.refl
C : _root_.Container
R : Type uβ
xβ y : R
x : Container.B (Container C R) (A.Pure xβ)
β’ eq (PEmpty.rec (fun x => M (Container C R)) x) (PEmpty.rec (fun x => M (Container C R)) x) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | apply x.elim | case hβ.Pure.refl
C : _root_.Container
R : Type uβ
xβ y : R
x : Container.B (Container C R) (A.Pure xβ)
β’ eq (PEmpty.rec (fun x => M (Container C R)) x) (PEmpty.rec (fun x => M (Container C R)) x) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | exists (A.Free node) | case hβ.Free
C : _root_.Container
R : Type uβ
node : C.A
kβ kβ : Container.B C node β Free C R
h : β (x : Container.B C node), (β₯ β β(pgfp (equivF' Eq)) β₯) (kβ x) (kβ x)
β’ β node_1 kβ_1 kβ_1,
M.destruct (construct (Functor.Free node kβ)) = { fst := node_1, snd := kβ_1 } β§
M.destruct (construct (Functor.Free node kβ)) = { fst := node_1, snd := kβ_1 } β§
β (i : Container.B (Container C R) node_1), eq (kβ_1 i) (kβ_1 i) | case hβ.Free
C : _root_.Container
R : Type uβ
node : C.A
kβ kβ : Container.B C node β Free C R
h : β (x : Container.B C node), (β₯ β β(pgfp (equivF' Eq)) β₯) (kβ x) (kβ x)
β’ β kβ_1 kβ_1,
M.destruct (construct (Functor.Free node kβ)) = { fst := A.Free node, snd := kβ_1 } β§
M.destruct (construct (Functor.Free node kβ)) = { fst := A.Free node, snd := kβ_1 } β§
β (i : Container.B (Container C R) (A.Free node)), eq (kβ_1 i) (kβ_1 i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | exists kβ | case hβ.Free
C : _root_.Container
R : Type uβ
node : C.A
kβ kβ : Container.B C node β Free C R
h : β (x : Container.B C node), (β₯ β β(pgfp (equivF' Eq)) β₯) (kβ x) (kβ x)
β’ β kβ_1 kβ_1,
M.destruct (construct (Functor.Free node kβ)) = { fst := A.Free node, snd := kβ_1 } β§
M.destruct (construct (Functor.Free node kβ)) = { fst := A.Free node, snd := kβ_1 } β§
β (i : Container.B (Container C R) (A.Free node)), eq (kβ_1 i) (kβ_1 i) | case hβ.Free
C : _root_.Container
R : Type uβ
node : C.A
kβ kβ : Container.B C node β Free C R
h : β (x : Container.B C node), (β₯ β β(pgfp (equivF' Eq)) β₯) (kβ x) (kβ x)
β’ β kβ_1,
M.destruct (construct (Functor.Free node kβ)) = { fst := A.Free node, snd := kβ } β§
M.destruct (construct (Functor.Free node kβ)) = { fst := A.Free node, snd := kβ_1 } β§
β (i : Container.B (Container C R) (A.Free node)), eq (kβ i) (kβ_1 i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | exists kβ | case hβ.Free
C : _root_.Container
R : Type uβ
node : C.A
kβ kβ : Container.B C node β Free C R
h : β (x : Container.B C node), (β₯ β β(pgfp (equivF' Eq)) β₯) (kβ x) (kβ x)
β’ β kβ_1,
M.destruct (construct (Functor.Free node kβ)) = { fst := A.Free node, snd := kβ } β§
M.destruct (construct (Functor.Free node kβ)) = { fst := A.Free node, snd := kβ_1 } β§
β (i : Container.B (Container C R) (A.Free node)), eq (kβ i) (kβ_1 i) | case hβ.Free
C : _root_.Container
R : Type uβ
node : C.A
kβ kβ : Container.B C node β Free C R
h : β (x : Container.B C node), (β₯ β β(pgfp (equivF' Eq)) β₯) (kβ x) (kβ x)
β’ M.destruct (construct (Functor.Free node kβ)) = { fst := A.Free node, snd := kβ } β§
M.destruct (construct (Functor.Free node kβ)) = { fst := A.Free node, snd := kβ } β§
β (i : Container.B (Container C R) (A.Free node)), eq (kβ i) (kβ i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | simp only [construct, M.destruct_construct, inv, true_and] | case hβ.Free
C : _root_.Container
R : Type uβ
node : C.A
kβ kβ : Container.B C node β Free C R
h : β (x : Container.B C node), (β₯ β β(pgfp (equivF' Eq)) β₯) (kβ x) (kβ x)
β’ M.destruct (construct (Functor.Free node kβ)) = { fst := A.Free node, snd := kβ } β§
M.destruct (construct (Functor.Free node kβ)) = { fst := A.Free node, snd := kβ } β§
β (i : Container.B (Container C R) (A.Free node)), eq (kβ i) (kβ i) | case hβ.Free
C : _root_.Container
R : Type uβ
node : C.A
kβ kβ : Container.B C node β Free C R
h : β (x : Container.B C node), (β₯ β β(pgfp (equivF' Eq)) β₯) (kβ x) (kβ x)
β’ β (i : Container.B (Container C R) (A.Free node)), eq (kβ i) (kβ i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | intro x | case hβ.Free
C : _root_.Container
R : Type uβ
node : C.A
kβ kβ : Container.B C node β Free C R
h : β (x : Container.B C node), (β₯ β β(pgfp (equivF' Eq)) β₯) (kβ x) (kβ x)
β’ β (i : Container.B (Container C R) (A.Free node)), eq (kβ i) (kβ i) | case hβ.Free
C : _root_.Container
R : Type uβ
node : C.A
kβ kβ : Container.B C node β Free C R
h : β (x : Container.B C node), (β₯ β β(pgfp (equivF' Eq)) β₯) (kβ x) (kβ x)
x : Container.B (Container C R) (A.Free node)
β’ eq (kβ x) (kβ x) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | rw [CompleteLattice.bot_sup] at h | case hβ.Free
C : _root_.Container
R : Type uβ
node : C.A
kβ kβ : Container.B C node β Free C R
h : β (x : Container.B C node), (β₯ β β(pgfp (equivF' Eq)) β₯) (kβ x) (kβ x)
x : Container.B (Container C R) (A.Free node)
β’ eq (kβ x) (kβ x) | case hβ.Free
C : _root_.Container
R : Type uβ
node : C.A
kβ kβ : Container.B C node β Free C R
h : β (x : Container.B C node), β(pgfp (equivF' Eq)) β₯ (kβ x) (kβ x)
x : Container.B (Container C R) (A.Free node)
β’ eq (kβ x) (kβ x) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | apply h | case hβ.Free
C : _root_.Container
R : Type uβ
node : C.A
kβ kβ : Container.B C node β Free C R
h : β (x : Container.B C node), β(pgfp (equivF' Eq)) β₯ (kβ x) (kβ x)
x : Container.B (Container C R) (A.Free node)
β’ eq (kβ x) (kβ x) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | have : β (x y:Free C R), x = y β Free.eq x y := by
apply Free.equiv.coinduction
intro x y h
cases h
conv =>
congr
. rfl
. rfl
. rw [βconstruct_destruct x]
. rw [βconstruct_destruct x]
cases destruct x with
| Pure r =>
apply equivF.Pure
rfl
| Free node k =>
apply equivF.Free
intro y
left
rfl | C : _root_.Container
R : Type uβ
β’ β (x : Free C R), eq x x | C : _root_.Container
R : Type uβ
this : β (x y : Free C R), x = y β eq x y
β’ β (x : Free C R), eq x x |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | intro x | C : _root_.Container
R : Type uβ
this : β (x y : Free C R), x = y β eq x y
β’ β (x : Free C R), eq x x | C : _root_.Container
R : Type uβ
this : β (x y : Free C R), x = y β eq x y
x : Free C R
β’ eq x x |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | apply this | C : _root_.Container
R : Type uβ
this : β (x y : Free C R), x = y β eq x y
x : Free C R
β’ eq x x | case a
C : _root_.Container
R : Type uβ
this : β (x y : Free C R), x = y β eq x y
x : Free C R
β’ x = x |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | rfl | case a
C : _root_.Container
R : Type uβ
this : β (x y : Free C R), x = y β eq x y
x : Free C R
β’ x = x | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | apply Free.equiv.coinduction | C : _root_.Container
R : Type uβ
β’ β (x y : Free C R), x = y β eq x y | case a
C : _root_.Container
R : Type uβ
β’ β (x y : Free C R), x = y β equivF Eq ((fun x y => x = y) β pequiv Eq fun x y => x = y) x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | intro x y h | case a
C : _root_.Container
R : Type uβ
β’ β (x y : Free C R), x = y β equivF Eq ((fun x y => x = y) β pequiv Eq fun x y => x = y) x y | case a
C : _root_.Container
R : Type uβ
x y : Free C R
h : x = y
β’ equivF Eq ((fun x y => x = y) β pequiv Eq fun x y => x = y) x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | cases h | case a
C : _root_.Container
R : Type uβ
x y : Free C R
h : x = y
β’ equivF Eq ((fun x y => x = y) β pequiv Eq fun x y => x = y) x y | case a.refl
C : _root_.Container
R : Type uβ
x : Free C R
β’ equivF Eq ((fun x y => x = y) β pequiv Eq fun x y => x = y) x x |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | conv =>
congr
. rfl
. rfl
. rw [βconstruct_destruct x]
. rw [βconstruct_destruct x] | case a.refl
C : _root_.Container
R : Type uβ
x : Free C R
β’ equivF Eq ((fun x y => x = y) β pequiv Eq fun x y => x = y) x x | case a.refl
C : _root_.Container
R : Type uβ
x : Free C R
β’ equivF Eq ((fun x y => x = y) β pequiv Eq fun x y => x = y) (construct (destruct x)) (construct (destruct x)) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | cases destruct x with
| Pure r =>
apply equivF.Pure
rfl
| Free node k =>
apply equivF.Free
intro y
left
rfl | case a.refl
C : _root_.Container
R : Type uβ
x : Free C R
β’ equivF Eq ((fun x y => x = y) β pequiv Eq fun x y => x = y) (construct (destruct x)) (construct (destruct x)) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | apply equivF.Pure | case a.refl.Pure
C : _root_.Container
R : Type uβ
x : Free C R
r : R
β’ equivF Eq ((fun x y => x = y) β pequiv Eq fun x y => x = y) (construct (Functor.Pure r)) (construct (Functor.Pure r)) | case a.refl.Pure.a
C : _root_.Container
R : Type uβ
x : Free C R
r : R
β’ r = r |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | rfl | case a.refl.Pure.a
C : _root_.Container
R : Type uβ
x : Free C R
r : R
β’ r = r | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | apply equivF.Free | case a.refl.Free
C : _root_.Container
R : Type uβ
x : Free C R
node : C.A
k : Container.B C node β Free C R
β’ equivF Eq ((fun x y => x = y) β pequiv Eq fun x y => x = y) (construct (Functor.Free node k))
(construct (Functor.Free node k)) | case a.refl.Free.a
C : _root_.Container
R : Type uβ
x : Free C R
node : C.A
k : Container.B C node β Free C R
β’ β (x : Container.B C node), ((fun x y => x = y) β pequiv Eq fun x y => x = y) (k x) (k x) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | intro y | case a.refl.Free.a
C : _root_.Container
R : Type uβ
x : Free C R
node : C.A
k : Container.B C node β Free C R
β’ β (x : Container.B C node), ((fun x y => x = y) β pequiv Eq fun x y => x = y) (k x) (k x) | case a.refl.Free.a
C : _root_.Container
R : Type uβ
x : Free C R
node : C.A
k : Container.B C node β Free C R
y : Container.B C node
β’ ((fun x y => x = y) β pequiv Eq fun x y => x = y) (k y) (k y) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | left | case a.refl.Free.a
C : _root_.Container
R : Type uβ
x : Free C R
node : C.A
k : Container.B C node β Free C R
y : Container.B C node
β’ ((fun x y => x = y) β pequiv Eq fun x y => x = y) (k y) (k y) | case a.refl.Free.a.h
C : _root_.Container
R : Type uβ
x : Free C R
node : C.A
k : Container.B C node β Free C R
y : Container.B C node
β’ (fun x y => x = y) (k y) (k y) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | rfl | case a.refl.Free.a.h
C : _root_.Container
R : Type uβ
x : Free C R
node : C.A
k : Container.B C node β Free C R
y : Container.B C node
β’ (fun x y => x = y) (k y) (k y) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | apply Free.eq.bisim | C : _root_.Container
R S : Type uβ
f : R β Free C S
x : Free C S
β’ corec (bind.automaton f) (Sum.inr x) = x | case a
C : _root_.Container
R S : Type uβ
f : R β Free C S
x : Free C S
β’ eq (corec (bind.automaton f) (Sum.inr x)) x |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | have : β x y, x = corec (bind.automaton f) (.inr y) β eq x y := by
apply Free.equiv.coinduction
intro x y hβ
conv =>
congr
. rfl
. rfl
. rw [βconstruct_destruct x]
. rw [βconstruct_destruct y]
have hβ := congrArg destruct hβ
clear hβ
rw [destruct_corec] at hβ
cases hy: destruct y with
| Pure r =>
simp only [Map, hy, bind.automaton] at hβ
rw [hβ]
apply equivF.Pure
rfl
| Free n k =>
simp only [Map, bind.automaton, hy] at hβ
rw [hβ]
apply equivF.Free
intro y
left
rfl | case a
C : _root_.Container
R S : Type uβ
f : R β Free C S
x : Free C S
β’ eq (corec (bind.automaton f) (Sum.inr x)) x | case a
C : _root_.Container
R S : Type uβ
f : R β Free C S
x : Free C S
this : β (x y : Free C S), x = corec (bind.automaton f) (Sum.inr y) β eq x y
β’ eq (corec (bind.automaton f) (Sum.inr x)) x |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | apply this | case a
C : _root_.Container
R S : Type uβ
f : R β Free C S
x : Free C S
this : β (x y : Free C S), x = corec (bind.automaton f) (Sum.inr y) β eq x y
β’ eq (corec (bind.automaton f) (Sum.inr x)) x | case a.a
C : _root_.Container
R S : Type uβ
f : R β Free C S
x : Free C S
this : β (x y : Free C S), x = corec (bind.automaton f) (Sum.inr y) β eq x y
β’ corec (bind.automaton f) (Sum.inr x) = corec (bind.automaton f) (Sum.inr x) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | rfl | case a.a
C : _root_.Container
R S : Type uβ
f : R β Free C S
x : Free C S
this : β (x y : Free C S), x = corec (bind.automaton f) (Sum.inr y) β eq x y
β’ corec (bind.automaton f) (Sum.inr x) = corec (bind.automaton f) (Sum.inr x) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | apply Free.equiv.coinduction | C : _root_.Container
R S : Type uβ
f : R β Free C S
x : Free C S
β’ β (x y : Free C S), x = corec (bind.automaton f) (Sum.inr y) β eq x y | case a
C : _root_.Container
R S : Type uβ
f : R β Free C S
x : Free C S
β’ β (x y : Free C S),
x = corec (bind.automaton f) (Sum.inr y) β
equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | intro x y hβ | case a
C : _root_.Container
R S : Type uβ
f : R β Free C S
x : Free C S
β’ β (x y : Free C S),
x = corec (bind.automaton f) (Sum.inr y) β
equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
x y | case a
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
hβ : x = corec (bind.automaton f) (Sum.inr y)
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | conv =>
congr
. rfl
. rfl
. rw [βconstruct_destruct x]
. rw [βconstruct_destruct y] | case a
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
hβ : x = corec (bind.automaton f) (Sum.inr y)
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
x y | case a
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
hβ : x = corec (bind.automaton f) (Sum.inr y)
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y)) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | have hβ := congrArg destruct hβ | case a
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
hβ : x = corec (bind.automaton f) (Sum.inr y)
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y)) | case a
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
hβ : x = corec (bind.automaton f) (Sum.inr y)
hβ : destruct x = destruct (corec (bind.automaton f) (Sum.inr y))
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y)) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | clear hβ | case a
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
hβ : x = corec (bind.automaton f) (Sum.inr y)
hβ : destruct x = destruct (corec (bind.automaton f) (Sum.inr y))
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y)) | case a
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
hβ : destruct x = destruct (corec (bind.automaton f) (Sum.inr y))
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y)) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | rw [destruct_corec] at hβ | case a
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
hβ : destruct x = destruct (corec (bind.automaton f) (Sum.inr y))
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y)) | case a
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
hβ : destruct x = Map (corec (bind.automaton f)) (bind.automaton f (Sum.inr y))
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y)) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | cases hy: destruct y with
| Pure r =>
simp only [Map, hy, bind.automaton] at hβ
rw [hβ]
apply equivF.Pure
rfl
| Free n k =>
simp only [Map, bind.automaton, hy] at hβ
rw [hβ]
apply equivF.Free
intro y
left
rfl | case a
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
hβ : destruct x = Map (corec (bind.automaton f)) (bind.automaton f (Sum.inr y))
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y)) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | simp only [Map, hy, bind.automaton] at hβ | case a.Pure
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
hβ : destruct x = Map (corec (bind.automaton f)) (bind.automaton f (Sum.inr y))
r : S
hy : destruct y = Functor.Pure r
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (Functor.Pure r)) | case a.Pure
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
r : S
hy : destruct y = Functor.Pure r
hβ : destruct x = Functor.Pure r
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (Functor.Pure r)) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | rw [hβ] | case a.Pure
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
r : S
hy : destruct y = Functor.Pure r
hβ : destruct x = Functor.Pure r
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (Functor.Pure r)) | case a.Pure
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
r : S
hy : destruct y = Functor.Pure r
hβ : destruct x = Functor.Pure r
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (Functor.Pure r)) (construct (Functor.Pure r)) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | apply equivF.Pure | case a.Pure
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
r : S
hy : destruct y = Functor.Pure r
hβ : destruct x = Functor.Pure r
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (Functor.Pure r)) (construct (Functor.Pure r)) | case a.Pure.a
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
r : S
hy : destruct y = Functor.Pure r
hβ : destruct x = Functor.Pure r
β’ r = r |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | rfl | case a.Pure.a
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
r : S
hy : destruct y = Functor.Pure r
hβ : destruct x = Functor.Pure r
β’ r = r | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | simp only [Map, bind.automaton, hy] at hβ | case a.Free
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
hβ : destruct x = Map (corec (bind.automaton f)) (bind.automaton f (Sum.inr y))
n : C.A
k : Container.B C n β Free C S
hy : destruct y = Functor.Free n k
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (Functor.Free n k)) | case a.Free
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
n : C.A
k : Container.B C n β Free C S
hy : destruct y = Functor.Free n k
hβ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (Functor.Free n k)) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | rw [hβ] | case a.Free
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
n : C.A
k : Container.B C n β Free C S
hy : destruct y = Functor.Free n k
hβ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (Functor.Free n k)) | case a.Free
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
n : C.A
k : Container.B C n β Free C S
hy : destruct y = Functor.Free n k
hβ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct
(Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)))
(construct (Functor.Free n k)) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | apply equivF.Free | case a.Free
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
n : C.A
k : Container.B C n β Free C S
hy : destruct y = Functor.Free n k
hβ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)
β’ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct
(Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)))
(construct (Functor.Free n k)) | case a.Free.a
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
n : C.A
k : Container.B C n β Free C S
hy : destruct y = Functor.Free n k
hβ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)
β’ β (x : Container.B C n),
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)
x)
(k x) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | intro y | case a.Free.a
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x y : Free C S
n : C.A
k : Container.B C n β Free C S
hy : destruct y = Functor.Free n k
hβ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)
β’ β (x : Container.B C n),
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)
x)
(k x) | case a.Free.a
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x yβ : Free C S
n : C.A
k : Container.B C n β Free C S
hy : destruct yβ = Functor.Free n k
hβ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)
y : Container.B C n
β’ ((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)
y)
(k y) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | left | case a.Free.a
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x yβ : Free C S
n : C.A
k : Container.B C n β Free C S
hy : destruct yβ = Functor.Free n k
hβ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)
y : Container.B C n
β’ ((fun x y => x = corec (bind.automaton f) (Sum.inr y)) β
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)
y)
(k y) | case a.Free.a.h
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x yβ : Free C S
n : C.A
k : Container.B C n β Free C S
hy : destruct yβ = Functor.Free n k
hβ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)
y : Container.B C n
β’ (fun x y => x = corec (bind.automaton f) (Sum.inr y))
(((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)
y)
(k y) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | rfl | case a.Free.a.h
C : _root_.Container
R S : Type uβ
f : R β Free C S
xβ x yβ : Free C S
n : C.A
k : Container.B C n β Free C S
hy : destruct yβ = Functor.Free n k
hβ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)
y : Container.B C n
β’ (fun x y => x = corec (bind.automaton f) (Sum.inr y))
(((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr β k)
| Functor.Free n k => Functor.Free n (Sum.inl β k)) β
Sum.inr β k)
y)
(k y) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | rw [βconstruct_destruct <| k r] | C : _root_.Container
R S : Type uβ
r : R
k : R β Free C S
β’ bind (pure r) k = k r | C : _root_.Container
R S : Type uβ
r : R
k : R β Free C S
β’ bind (pure r) k = construct (destruct (k r)) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | rw [βconstruct_destruct <| bind (pure r) k] | C : _root_.Container
R S : Type uβ
r : R
k : R β Free C S
β’ bind (pure r) k = construct (destruct (k r)) | C : _root_.Container
R S : Type uβ
r : R
k : R β Free C S
β’ construct (destruct (bind (pure r) k)) = construct (destruct (k r)) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | simp only [bind, pure, destruct_corec] | C : _root_.Container
R S : Type uβ
r : R
k : R β Free C S
β’ construct (destruct (bind (pure r) k)) = construct (destruct (k r)) | C : _root_.Container
R S : Type uβ
r : R
k : R β Free C S
β’ construct (Map (corec (bind.automaton k)) (bind.automaton k (Sum.inl (construct (Functor.Pure r))))) =
construct (destruct (k r)) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | apply congrArg construct | C : _root_.Container
R S : Type uβ
r : R
k : R β Free C S
β’ construct (Map (corec (bind.automaton k)) (bind.automaton k (Sum.inl (construct (Functor.Pure r))))) =
construct (destruct (k r)) | C : _root_.Container
R S : Type uβ
r : R
k : R β Free C S
β’ Map (corec (bind.automaton k)) (bind.automaton k (Sum.inl (construct (Functor.Pure r)))) = destruct (k r) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | conv =>
lhs
congr
. rfl
. simp only [bind.automaton, destruct_construct] | C : _root_.Container
R S : Type uβ
r : R
k : R β Free C S
β’ Map (corec (bind.automaton k)) (bind.automaton k (Sum.inl (construct (Functor.Pure r)))) = destruct (k r) | C : _root_.Container
R S : Type uβ
r : R
k : R β Free C S
β’ Map (corec (bind.automaton k)) (Map Sum.inr (destruct (k r))) = destruct (k r) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | cases destruct (k r) with
| Pure r =>
simp only [Map]
| Free n k =>
simp only [Map]
conv =>
lhs
congr
simp only [Function.comp]
intro x
rw [bind_inr] | C : _root_.Container
R S : Type uβ
r : R
k : R β Free C S
β’ Map (corec (bind.automaton k)) (Map Sum.inr (destruct (k r))) = destruct (k r) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | simp only [Map] | case Pure
C : _root_.Container
R S : Type uβ
rβ : R
k : R β Free C S
r : S
β’ Map (corec (bind.automaton k)) (Map Sum.inr (Functor.Pure r)) = Functor.Pure r | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | simp only [Map] | case Free
C : _root_.Container
R S : Type uβ
r : R
kβ : R β Free C S
n : C.A
k : Container.B C n β Free C S
β’ Map (corec (bind.automaton kβ)) (Map Sum.inr (Functor.Free n k)) = Functor.Free n k | case Free
C : _root_.Container
R S : Type uβ
r : R
kβ : R β Free C S
n : C.A
k : Container.B C n β Free C S
β’ Functor.Free n (corec (bind.automaton kβ) β Sum.inr β k) = Functor.Free n k |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | conv =>
lhs
congr
simp only [Function.comp]
intro x
rw [bind_inr] | case Free
C : _root_.Container
R S : Type uβ
r : R
kβ : R β Free C S
n : C.A
k : Container.B C n β Free C S
β’ Functor.Free n (corec (bind.automaton kβ) β Sum.inr β k) = Functor.Free n k | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.wf_destruct | [72, 1] | [79, 10] | simp only [WellFormed, PWellFormed] at wf | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wf : WellFormed i m
β’ β (x : B C (Container.M.destruct β{ val := m, property := wf }).fst),
WellFormed (Next C (Container.M.destruct β{ val := m, property := wf }).fst x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wf }) x) | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wf : β(pgfp (WellFormedF C)) β₯ i m
β’ β (x : B C (Container.M.destruct β{ val := m, property := wf }).fst),
WellFormed (Next C (Container.M.destruct β{ val := m, property := wf }).fst x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wf }) x) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.wf_destruct | [72, 1] | [79, 10] | rw [βpgfp.unfold] at wf | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wf : β(pgfp (WellFormedF C)) β₯ i m
β’ β (x : B C (Container.M.destruct β{ val := m, property := wf }).fst),
WellFormed (Next C (Container.M.destruct β{ val := m, property := wf }).fst x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wf }) x) | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β₯ β β(pgfp (WellFormedF C)) β₯) i m
β’ β (x : B C (Container.M.destruct β{ val := m, property := wfβ }).fst),
WellFormed (Next C (Container.M.destruct β{ val := m, property := wfβ }).fst x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wfβ }) x) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.wf_destruct | [72, 1] | [79, 10] | simp only [CompleteLattice.bot_sup] at wf | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β₯ β β(pgfp (WellFormedF C)) β₯) i m
β’ β (x : B C (Container.M.destruct β{ val := m, property := wfβ }).fst),
WellFormed (Next C (Container.M.destruct β{ val := m, property := wfβ }).fst x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wfβ }) x) | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β(pgfp (WellFormedF C)) β₯) i m
β’ β (x : B C (Container.M.destruct β{ val := m, property := wfβ }).fst),
WellFormed (Next C (Container.M.destruct β{ val := m, property := wfβ }).fst x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wfβ }) x) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.wf_destruct | [72, 1] | [79, 10] | have β¨_, yβ© := wf | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β(pgfp (WellFormedF C)) β₯) i m
β’ β (x : B C (Container.M.destruct β{ val := m, property := wfβ }).fst),
WellFormed (Next C (Container.M.destruct β{ val := m, property := wfβ }).fst x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wfβ }) x) | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β(pgfp (WellFormedF C)) β₯) i m
leftβ : Idx C (Container.M.destruct m).fst = i
y :
β (x : B C (Container.M.destruct m).fst),
β(pgfp (WellFormedF C)) β₯ (Next C (Container.M.destruct m).fst x) (PSigma.snd (Container.M.destruct m) x)
β’ β (x : B C (Container.M.destruct β{ val := m, property := wfβ }).fst),
WellFormed (Next C (Container.M.destruct β{ val := m, property := wfβ }).fst x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wfβ }) x) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.wf_destruct | [72, 1] | [79, 10] | exact y | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β(pgfp (WellFormedF C)) β₯) i m
leftβ : Idx C (Container.M.destruct m).fst = i
y :
β (x : B C (Container.M.destruct m).fst),
β(pgfp (WellFormedF C)) β₯ (Next C (Container.M.destruct m).fst x) (PSigma.snd (Container.M.destruct m) x)
β’ β (x : B C (Container.M.destruct β{ val := m, property := wfβ }).fst),
WellFormed (Next C (Container.M.destruct β{ val := m, property := wfβ }).fst x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wfβ }) x) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.index_destruct | [81, 1] | [88, 10] | simp only [WellFormed, PWellFormed] at wf | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wf : WellFormed i m
β’ i = Idx C (Container.M.destruct β{ val := m, property := wf }).fst | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wf : β(pgfp (WellFormedF C)) β₯ i m
β’ i = Idx C (Container.M.destruct β{ val := m, property := wf }).fst |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.index_destruct | [81, 1] | [88, 10] | rw [βpgfp.unfold] at wf | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wf : β(pgfp (WellFormedF C)) β₯ i m
β’ i = Idx C (Container.M.destruct β{ val := m, property := wf }).fst | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β₯ β β(pgfp (WellFormedF C)) β₯) i m
β’ i = Idx C (Container.M.destruct β{ val := m, property := wfβ }).fst |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.index_destruct | [81, 1] | [88, 10] | simp only [CompleteLattice.bot_sup] at wf | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β₯ β β(pgfp (WellFormedF C)) β₯) i m
β’ i = Idx C (Container.M.destruct β{ val := m, property := wfβ }).fst | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β(pgfp (WellFormedF C)) β₯) i m
β’ i = Idx C (Container.M.destruct β{ val := m, property := wfβ }).fst |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.index_destruct | [81, 1] | [88, 10] | have β¨x, _β© := wf | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β(pgfp (WellFormedF C)) β₯) i m
β’ i = Idx C (Container.M.destruct β{ val := m, property := wfβ }).fst | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β(pgfp (WellFormedF C)) β₯) i m
x : Idx C (Container.M.destruct m).fst = i
rightβ :
β (x : B C (Container.M.destruct m).fst),
β(pgfp (WellFormedF C)) β₯ (Next C (Container.M.destruct m).fst x) (PSigma.snd (Container.M.destruct m) x)
β’ i = Idx C (Container.M.destruct β{ val := m, property := wfβ }).fst |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.index_destruct | [81, 1] | [88, 10] | apply Eq.symm | I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β(pgfp (WellFormedF C)) β₯) i m
x : Idx C (Container.M.destruct m).fst = i
rightβ :
β (x : B C (Container.M.destruct m).fst),
β(pgfp (WellFormedF C)) β₯ (Next C (Container.M.destruct m).fst x) (PSigma.snd (Container.M.destruct m) x)
β’ i = Idx C (Container.M.destruct β{ val := m, property := wfβ }).fst | case h
I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β(pgfp (WellFormedF C)) β₯) i m
x : Idx C (Container.M.destruct m).fst = i
rightβ :
β (x : B C (Container.M.destruct m).fst),
β(pgfp (WellFormedF C)) β₯ (Next C (Container.M.destruct m).fst x) (PSigma.snd (Container.M.destruct m) x)
β’ Idx C (Container.M.destruct β{ val := m, property := wfβ }).fst = i |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.index_destruct | [81, 1] | [88, 10] | exact x | case h
I : Type uβ
C : IContainer' I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β(pgfp (WellFormedF C)) β₯) i m
x : Idx C (Container.M.destruct m).fst = i
rightβ :
β (x : B C (Container.M.destruct m).fst),
β(pgfp (WellFormedF C)) β₯ (Next C (Container.M.destruct m).fst x) (PSigma.snd (Container.M.destruct m) x)
β’ Idx C (Container.M.destruct β{ val := m, property := wfβ }).fst = i | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | intro β¨x, wfxβ© β¨y, wfyβ© hβ | I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
β’ β (x y : M C i), R i x y β x = y | I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
hβ : R i { val := x, property := wfx } { val := y, property := wfy }
β’ { val := x, property := wfx } = { val := y, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | suffices h: x = y by
induction h
rfl | I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
hβ : R i { val := x, property := wfx } { val := y, property := wfy }
β’ { val := x, property := wfx } = { val := y, property := wfy } | I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
hβ : R i { val := x, property := wfx } { val := y, property := wfy }
β’ x = y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | apply Container.M.bisim (Ξ» x y => β i, β (wfx: WellFormed i x) (wfy:WellFormed i y), R i β¨x, wfxβ© β¨y, wfyβ©) | I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
hβ : R i { val := x, property := wfx } { val := y, property := wfy }
β’ x = y | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
hβ : R i { val := x, property := wfx } { val := y, property := wfy }
β’ β (x y : Container.M (toContainer C)),
(β i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy }) β
β node kβ kβ,
Container.M.destruct x = { fst := node, snd := kβ } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i : Container.B (toContainer C) node),
β i_1 wfx wfy, R i_1 { val := kβ i, property := wfx } { val := kβ i, property := wfy }
case a
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
hβ : R i { val := x, property := wfx } { val := y, property := wfy }
β’ β i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | . intro x y β¨i, wfx, wfy, rβ©
have β¨β¨node, hββ©, kβ, kβ, hβ, hβ, hββ© := hβ i β¨x, wfxβ© β¨y, wfyβ© r
have hβ := lift_destruct_eq _ _ _ _ hβ
have hβ := lift_destruct_eq _ _ _ _ hβ
have wfx' := wf_destruct β¨x, wfxβ©
have wfy' := wf_destruct β¨y, wfyβ©
exists node
exists Ξ» a => (kβ a).1
exists Ξ» x => (kβ x).1
simp only [hβ, hβ, true_and]
intro a
exists C.Next node a
simp only [toContainer] at a
exists (by
rw [hβ] at wfx'
apply wfx'
)
exists (by
rw [hβ] at wfy'
apply wfy'
)
exact hβ a | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
hβ : R i { val := x, property := wfx } { val := y, property := wfy }
β’ β (x y : Container.M (toContainer C)),
(β i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy }) β
β node kβ kβ,
Container.M.destruct x = { fst := node, snd := kβ } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i : Container.B (toContainer C) node),
β i_1 wfx wfy, R i_1 { val := kβ i, property := wfx } { val := kβ i, property := wfy }
case a
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
hβ : R i { val := x, property := wfx } { val := y, property := wfy }
β’ β i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy } | case a
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
hβ : R i { val := x, property := wfx } { val := y, property := wfy }
β’ β i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists i | case a
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
hβ : R i { val := x, property := wfx } { val := y, property := wfy }
β’ β i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy } | case a
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
hβ : R i { val := x, property := wfx } { val := y, property := wfy }
β’ β wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists wfx | case a
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
hβ : R i { val := x, property := wfx } { val := y, property := wfy }
β’ β wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy } | case a
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
hβ : R i { val := x, property := wfx } { val := y, property := wfy }
β’ β wfy, R i { val := x, property := wfx } { val := y, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists wfy | case a
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
hβ : R i { val := x, property := wfx } { val := y, property := wfy }
β’ β wfy, R i { val := x, property := wfx } { val := y, property := wfy } | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | induction h | I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
hβ : R i { val := x, property := wfx } { val := y, property := wfy }
h : x = y
β’ { val := x, property := wfx } = { val := y, property := wfy } | case refl
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i x
hβ : R i { val := x, property := wfx } { val := x, property := wfy }
β’ { val := x, property := wfx } = { val := x, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | rfl | case refl
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i x
hβ : R i { val := x, property := wfx } { val := x, property := wfy }
β’ { val := x, property := wfx } = { val := x, property := wfy } | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | intro x y β¨i, wfx, wfy, rβ© | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
hβ : R i { val := x, property := wfx } { val := y, property := wfy }
β’ β (x y : Container.M (toContainer C)),
(β i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy }) β
β node kβ kβ,
Container.M.destruct x = { fst := node, snd := kβ } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i : Container.B (toContainer C) node),
β i_1 wfx wfy, R i_1 { val := kβ i, property := wfx } { val := kβ i, property := wfy } | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hβ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
β’ β node kβ kβ,
Container.M.destruct x = { fst := node, snd := kβ } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i : Container.B (toContainer C) node),
β i_1 wfx wfy, R i_1 { val := kβ i, property := wfx } { val := kβ i, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | have β¨β¨node, hββ©, kβ, kβ, hβ, hβ, hββ© := hβ i β¨x, wfxβ© β¨y, wfyβ© r | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hβ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
β’ β node kβ kβ,
Container.M.destruct x = { fst := node, snd := kβ } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i : Container.B (toContainer C) node),
β i_1 wfx wfy, R i_1 { val := kβ i, property := wfx } { val := kβ i, property := wfy } | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hβ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
β’ β node kβ kβ,
Container.M.destruct x = { fst := node, snd := kβ } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i : Container.B (toContainer C) node),
β i_1 wfx wfy, R i_1 { val := kβ i, property := wfx } { val := kβ i, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | have hβ := lift_destruct_eq _ _ _ _ hβ | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hβ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
β’ β node kβ kβ,
Container.M.destruct x = { fst := node, snd := kβ } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i : Container.B (toContainer C) node),
β i_1 wfx wfy, R i_1 { val := kβ i, property := wfx } { val := kβ i, property := wfy } | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
β’ β node kβ kβ,
Container.M.destruct x = { fst := node, snd := kβ } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i : Container.B (toContainer C) node),
β i_1 wfx wfy, R i_1 { val := kβ i, property := wfx } { val := kβ i, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | have hβ := lift_destruct_eq _ _ _ _ hβ | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
β’ β node kβ kβ,
Container.M.destruct x = { fst := node, snd := kβ } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i : Container.B (toContainer C) node),
β i_1 wfx wfy, R i_1 { val := kβ i, property := wfx } { val := kβ i, property := wfy } | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
β’ β node kβ kβ,
Container.M.destruct x = { fst := node, snd := kβ } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i : Container.B (toContainer C) node),
β i_1 wfx wfy, R i_1 { val := kβ i, property := wfx } { val := kβ i, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | have wfx' := wf_destruct β¨x, wfxβ© | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
β’ β node kβ kβ,
Container.M.destruct x = { fst := node, snd := kβ } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i : Container.B (toContainer C) node),
β i_1 wfx wfy, R i_1 { val := kβ i, property := wfx } { val := kβ i, property := wfy } | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
β’ β node kβ kβ,
Container.M.destruct x = { fst := node, snd := kβ } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i : Container.B (toContainer C) node),
β i_1 wfx wfy, R i_1 { val := kβ i, property := wfx } { val := kβ i, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | have wfy' := wf_destruct β¨y, wfyβ© | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
β’ β node kβ kβ,
Container.M.destruct x = { fst := node, snd := kβ } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i : Container.B (toContainer C) node),
β i_1 wfx wfy, R i_1 { val := kβ i, property := wfx } { val := kβ i, property := wfy } | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
β’ β node kβ kβ,
Container.M.destruct x = { fst := node, snd := kβ } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i : Container.B (toContainer C) node),
β i_1 wfx wfy, R i_1 { val := kβ i, property := wfx } { val := kβ i, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists node | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
β’ β node kβ kβ,
Container.M.destruct x = { fst := node, snd := kβ } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i : Container.B (toContainer C) node),
β i_1 wfx wfy, R i_1 { val := kβ i, property := wfx } { val := kβ i, property := wfy } | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
β’ β kβ kβ,
Container.M.destruct x = { fst := node, snd := kβ } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i : Container.B (toContainer C) node),
β i_1 wfx wfy, R i_1 { val := kβ i, property := wfx } { val := kβ i, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists Ξ» a => (kβ a).1 | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
β’ β kβ kβ,
Container.M.destruct x = { fst := node, snd := kβ } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i : Container.B (toContainer C) node),
β i_1 wfx wfy, R i_1 { val := kβ i, property := wfx } { val := kβ i, property := wfy } | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
β’ β kβ,
Container.M.destruct x = { fst := node, snd := fun a => β(kβ a) } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i_1 : Container.B (toContainer C) node),
β i_2 wfx wfy, R i_2 { val := (fun a => β(kβ a)) i_1, property := wfx } { val := kβ i_1, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists Ξ» x => (kβ x).1 | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
β’ β kβ,
Container.M.destruct x = { fst := node, snd := fun a => β(kβ a) } β§
Container.M.destruct y = { fst := node, snd := kβ } β§
β (i_1 : Container.B (toContainer C) node),
β i_2 wfx wfy, R i_2 { val := (fun a => β(kβ a)) i_1, property := wfx } { val := kβ i_1, property := wfy } | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
β’ Container.M.destruct x = { fst := node, snd := fun a => β(kβ a) } β§
Container.M.destruct y = { fst := node, snd := fun x => β(kβ x) } β§
β (i_1 : Container.B (toContainer C) node),
β i_2 wfx wfy,
R i_2 { val := (fun a => β(kβ a)) i_1, property := wfx } { val := (fun x => β(kβ x)) i_1, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | simp only [hβ, hβ, true_and] | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
β’ Container.M.destruct x = { fst := node, snd := fun a => β(kβ a) } β§
Container.M.destruct y = { fst := node, snd := fun x => β(kβ x) } β§
β (i_1 : Container.B (toContainer C) node),
β i_2 wfx wfy,
R i_2 { val := (fun a => β(kβ a)) i_1, property := wfx } { val := (fun x => β(kβ x)) i_1, property := wfy } | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
β’ β (i_1 : Container.B (toContainer C) node),
β i_2 h h_1,
R i_2 { val := β(kβ i_1), property := (_ : WellFormed i_2 ((fun a => β(kβ a)) i_1)) }
{ val := β(kβ i_1), property := (_ : WellFormed i_2 ((fun x => β(kβ x)) i_1)) } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | intro a | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
β’ β (i_1 : Container.B (toContainer C) node),
β i_2 h h_1,
R i_2 { val := β(kβ i_1), property := (_ : WellFormed i_2 ((fun a => β(kβ a)) i_1)) }
{ val := β(kβ i_1), property := (_ : WellFormed i_2 ((fun x => β(kβ x)) i_1)) } | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
a : Container.B (toContainer C) node
β’ β i_1 h h_1,
R i_1 { val := β(kβ a), property := (_ : WellFormed i_1 ((fun a => β(kβ a)) a)) }
{ val := β(kβ a), property := (_ : WellFormed i_1 ((fun x => β(kβ x)) a)) } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists C.Next node a | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
a : Container.B (toContainer C) node
β’ β i_1 h h_1,
R i_1 { val := β(kβ a), property := (_ : WellFormed i_1 ((fun a => β(kβ a)) a)) }
{ val := β(kβ a), property := (_ : WellFormed i_1 ((fun x => β(kβ x)) a)) } | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
a : Container.B (toContainer C) node
β’ β h h_1,
R (Next C node a) { val := β(kβ a), property := (_ : WellFormed (Next C node a) ((fun a => β(kβ a)) a)) }
{ val := β(kβ a), property := (_ : WellFormed (Next C node a) ((fun x => β(kβ x)) a)) } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | simp only [toContainer] at a | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
a : Container.B (toContainer C) node
β’ β h h_1,
R (Next C node a) { val := β(kβ a), property := (_ : WellFormed (Next C node a) ((fun a => β(kβ a)) a)) }
{ val := β(kβ a), property := (_ : WellFormed (Next C node a) ((fun x => β(kβ x)) a)) } | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
a : B C node
β’ β h h_1,
R (Next C node a) { val := β(kβ a), property := (_ : WellFormed (Next C node a) ((fun a => β(kβ a)) a)) }
{ val := β(kβ a), property := (_ : WellFormed (Next C node a) ((fun x => β(kβ x)) a)) } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists (by
rw [hβ] at wfx'
apply wfx'
) | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
a : B C node
β’ β h h_1,
R (Next C node a) { val := β(kβ a), property := (_ : WellFormed (Next C node a) ((fun a => β(kβ a)) a)) }
{ val := β(kβ a), property := (_ : WellFormed (Next C node a) ((fun x => β(kβ x)) a)) } | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
a : B C node
β’ β h,
R (Next C node a) { val := β(kβ a), property := (_ : WellFormed (Next C node a) ((fun a => β(kβ a)) a)) }
{ val := β(kβ a), property := (_ : WellFormed (Next C node a) ((fun x => β(kβ x)) a)) } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists (by
rw [hβ] at wfy'
apply wfy'
) | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
a : B C node
β’ β h,
R (Next C node a) { val := β(kβ a), property := (_ : WellFormed (Next C node a) ((fun a => β(kβ a)) a)) }
{ val := β(kβ a), property := (_ : WellFormed (Next C node a) ((fun x => β(kβ x)) a)) } | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
a : B C node
β’ R (Next C node a) { val := β(kβ a), property := (_ : WellFormed (Next C node a) ((fun a => β(kβ a)) a)) }
{ val := β(kβ a), property := (_ : WellFormed (Next C node a) ((fun x => β(kβ x)) a)) } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exact hβ a | case hβ
I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
a : B C node
β’ R (Next C node a) { val := β(kβ a), property := (_ : WellFormed (Next C node a) ((fun a => β(kβ a)) a)) }
{ val := β(kβ a), property := (_ : WellFormed (Next C node a) ((fun x => β(kβ x)) a)) } | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | rw [hβ] at wfx' | I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
a : B C node
β’ WellFormed (Next C node a) β(kβ a) | I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β
(x :
B C
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }.fst),
WellFormed
(Next C
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }.fst
x)
(PSigma.snd
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
x)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
a : B C node
β’ WellFormed (Next C node a) β(kβ a) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | apply wfx' | I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β
(x :
B C
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }.fst),
WellFormed
(Next C
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }.fst
x)
(PSigma.snd
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
x)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
a : B C node
β’ WellFormed (Next C node a) β(kβ a) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | rw [hβ] at wfy' | I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β (x : B C (Container.M.destruct β{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct β{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct β{ val := y, property := wfy }) x)
a : B C node
β’ WellFormed (Next C node a) β(kβ a) | I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β
(x :
B C
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }.fst),
WellFormed
(Next C
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }.fst
x)
(PSigma.snd
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
x)
a : B C node
β’ WellFormed (Next C node a) β(kβ a) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | apply wfy' | I : Type uβ
C : IContainer' I
R : (i : I) β M C i β M C i β Prop
hβ :
β (i : I) (x y : M C i),
R i x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (z : B C βnode), R (Next C (βnode) z) (kβ z) (kβ z)
iβ : I
xβ : Container.M (toContainer C)
wfxβ : WellFormed iβ xβ
yβ : Container.M (toContainer C)
wfyβ : WellFormed iβ yβ
hββΒΉ : R iβ { val := xβ, property := wfxβ } { val := yβ, property := wfyβ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
hβ : i = Idx C node
kβ kβ : (y : B C β{ val := node, property := hβ }) β M C (Next C (β{ val := node, property := hβ }) y)
hββ : destruct { val := x, property := wfx } = { fst := { val := node, property := hβ }, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := { val := node, property := hβ }, snd := kβ }
hβ : β (z : B C β{ val := node, property := hβ }), R (Next C (β{ val := node, property := hβ }) z) (kβ z) (kβ z)
hβ :
Container.M.destruct x =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
hβ :
Container.M.destruct y =
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
wfx' :
β (x_1 : B C (Container.M.destruct β{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct β{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct β{ val := x, property := wfx }) x_1)
wfy' :
β
(x :
B C
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }.fst),
WellFormed
(Next C
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }.fst
x)
(PSigma.snd
{ fst := β{ fst := { val := node, property := hβ }, snd := kβ }.fst,
snd := fun x => β(Sigma.snd { fst := { val := node, property := hβ }, snd := kβ } x) }
x)
a : B C node
β’ WellFormed (Next C node a) β(kβ a) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.wf_destruct | [50, 1] | [57, 10] | simp only [WellFormed, PWellFormed] at wf | I : Type uβ
C : IContainer I
i : I
xβ : M C i
m : Container.M (toContainer C)
wf : WellFormed i m
β’ β
(x :
B C (Container.M.destruct β{ val := m, property := wf }).fst.fst
(Container.M.destruct β{ val := m, property := wf }).fst.snd),
WellFormed
(N C (Container.M.destruct β{ val := m, property := wf }).fst.fst
(Container.M.destruct β{ val := m, property := wf }).fst.snd x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wf }) x) | I : Type uβ
C : IContainer I
i : I
xβ : M C i
m : Container.M (toContainer C)
wf : β(pgfp (WellFormedF C)) β₯ i m
β’ β
(x :
B C (Container.M.destruct β{ val := m, property := wf }).fst.fst
(Container.M.destruct β{ val := m, property := wf }).fst.snd),
WellFormed
(N C (Container.M.destruct β{ val := m, property := wf }).fst.fst
(Container.M.destruct β{ val := m, property := wf }).fst.snd x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wf }) x) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.wf_destruct | [50, 1] | [57, 10] | rw [βpgfp.unfold] at wf | I : Type uβ
C : IContainer I
i : I
xβ : M C i
m : Container.M (toContainer C)
wf : β(pgfp (WellFormedF C)) β₯ i m
β’ β
(x :
B C (Container.M.destruct β{ val := m, property := wf }).fst.fst
(Container.M.destruct β{ val := m, property := wf }).fst.snd),
WellFormed
(N C (Container.M.destruct β{ val := m, property := wf }).fst.fst
(Container.M.destruct β{ val := m, property := wf }).fst.snd x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wf }) x) | I : Type uβ
C : IContainer I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β₯ β β(pgfp (WellFormedF C)) β₯) i m
β’ β
(x :
B C (Container.M.destruct β{ val := m, property := wfβ }).fst.fst
(Container.M.destruct β{ val := m, property := wfβ }).fst.snd),
WellFormed
(N C (Container.M.destruct β{ val := m, property := wfβ }).fst.fst
(Container.M.destruct β{ val := m, property := wfβ }).fst.snd x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wfβ }) x) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.wf_destruct | [50, 1] | [57, 10] | simp only [CompleteLattice.bot_sup] at wf | I : Type uβ
C : IContainer I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β₯ β β(pgfp (WellFormedF C)) β₯) i m
β’ β
(x :
B C (Container.M.destruct β{ val := m, property := wfβ }).fst.fst
(Container.M.destruct β{ val := m, property := wfβ }).fst.snd),
WellFormed
(N C (Container.M.destruct β{ val := m, property := wfβ }).fst.fst
(Container.M.destruct β{ val := m, property := wfβ }).fst.snd x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wfβ }) x) | I : Type uβ
C : IContainer I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β(pgfp (WellFormedF C)) β₯) i m
β’ β
(x :
B C (Container.M.destruct β{ val := m, property := wfβ }).fst.fst
(Container.M.destruct β{ val := m, property := wfβ }).fst.snd),
WellFormed
(N C (Container.M.destruct β{ val := m, property := wfβ }).fst.fst
(Container.M.destruct β{ val := m, property := wfβ }).fst.snd x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wfβ }) x) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.wf_destruct | [50, 1] | [57, 10] | have β¨_, yβ© := wf | I : Type uβ
C : IContainer I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β(pgfp (WellFormedF C)) β₯) i m
β’ β
(x :
B C (Container.M.destruct β{ val := m, property := wfβ }).fst.fst
(Container.M.destruct β{ val := m, property := wfβ }).fst.snd),
WellFormed
(N C (Container.M.destruct β{ val := m, property := wfβ }).fst.fst
(Container.M.destruct β{ val := m, property := wfβ }).fst.snd x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wfβ }) x) | I : Type uβ
C : IContainer I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β(pgfp (WellFormedF C)) β₯) i m
leftβ : (Container.M.destruct m).fst.fst = i
y :
β (x : B C (Container.M.destruct m).fst.fst (Container.M.destruct m).fst.snd),
β(pgfp (WellFormedF C)) β₯ (N C (Container.M.destruct m).fst.fst (Container.M.destruct m).fst.snd x)
(PSigma.snd (Container.M.destruct m) x)
β’ β
(x :
B C (Container.M.destruct β{ val := m, property := wfβ }).fst.fst
(Container.M.destruct β{ val := m, property := wfβ }).fst.snd),
WellFormed
(N C (Container.M.destruct β{ val := m, property := wfβ }).fst.fst
(Container.M.destruct β{ val := m, property := wfβ }).fst.snd x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wfβ }) x) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.wf_destruct | [50, 1] | [57, 10] | exact y | I : Type uβ
C : IContainer I
i : I
xβ : M C i
m : Container.M (toContainer C)
wfβ : β(pgfp (WellFormedF C)) β₯ i m
wf : β(WellFormedF C) (β(pgfp (WellFormedF C)) β₯) i m
leftβ : (Container.M.destruct m).fst.fst = i
y :
β (x : B C (Container.M.destruct m).fst.fst (Container.M.destruct m).fst.snd),
β(pgfp (WellFormedF C)) β₯ (N C (Container.M.destruct m).fst.fst (Container.M.destruct m).fst.snd x)
(PSigma.snd (Container.M.destruct m) x)
β’ β
(x :
B C (Container.M.destruct β{ val := m, property := wfβ }).fst.fst
(Container.M.destruct β{ val := m, property := wfβ }).fst.snd),
WellFormed
(N C (Container.M.destruct β{ val := m, property := wfβ }).fst.fst
(Container.M.destruct β{ val := m, property := wfβ }).fst.snd x)
(PSigma.snd (Container.M.destruct β{ val := m, property := wfβ }) x) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.index_destruct | [59, 1] | [66, 10] | simp only [WellFormed, PWellFormed] at wf | I : Type uβ
C : IContainer I
i : I
xβ : M C i
m : Container.M (toContainer C)
wf : WellFormed i m
β’ i = (Container.M.destruct β{ val := m, property := wf }).fst.fst | I : Type uβ
C : IContainer I
i : I
xβ : M C i
m : Container.M (toContainer C)
wf : β(pgfp (WellFormedF C)) β₯ i m
β’ i = (Container.M.destruct β{ val := m, property := wf }).fst.fst |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.