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/MIdx.lean | IContainer.M.index_destruct | [59, 1] | [66, 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 = (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
wf : β(WellFormedF C) (β₯ β β(pgfp (WellFormedF C)) β₯) i m
β’ i = (Container.M.destruct β{ val := m, property := wfβ }).fst.fst |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.index_destruct | [59, 1] | [66, 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 = (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
wf : β(WellFormedF C) (β(pgfp (WellFormedF C)) β₯) i m
β’ i = (Container.M.destruct β{ val := m, property := wfβ }).fst.fst |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.index_destruct | [59, 1] | [66, 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 = (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
wf : β(WellFormedF C) (β(pgfp (WellFormedF C)) β₯) i m
x : (Container.M.destruct m).fst.fst = i
rightβ :
β (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)
β’ i = (Container.M.destruct β{ val := m, property := wfβ }).fst.fst |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.index_destruct | [59, 1] | [66, 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 : (Container.M.destruct m).fst.fst = i
rightβ :
β (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)
β’ i = (Container.M.destruct β{ val := m, property := wfβ }).fst.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 : (Container.M.destruct m).fst.fst = i
rightβ :
β (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)
β’ (Container.M.destruct β{ val := m, property := wfβ }).fst.fst = i |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.index_destruct | [59, 1] | [66, 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 : (Container.M.destruct m).fst.fst = i
rightβ :
β (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)
β’ (Container.M.destruct β{ val := m, property := wfβ }).fst.fst = i | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 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 i node), R (N C i 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 i node), R (N C i 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 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 i node), R (N C i 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 i node), R (N C i 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 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 i node), R (N C i 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 i node), R (N C i 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 i node), R (N C i 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | . intro x y β¨i, wfx, wfy, rβ©
have β¨node, kβ, kβ, hβ, hβ, hββ© := hβ i β¨x, wfxβ© β¨y, wfyβ© r
let ix := (Container.M.destruct x).1.1
let nx := (Container.M.destruct x).1.2
let kx := (Container.M.destruct x).2
let iy := (Container.M.destruct y).1.1
let ny := (Container.M.destruct y).1.2
let ky := (Container.M.destruct y).2
have hix := index_destruct β¨x, wfxβ©
have hiy := index_destruct β¨y, wfyβ©
have wfx' : β a:B C ix nx, WellFormed (C.N ix nx a) (kx a) := wf_destruct β¨x, wfxβ©
have wfy' : β a:B C iy ny, WellFormed (C.N iy ny a) (ky a) := wf_destruct β¨y, wfyβ©
simp only at hix hiy wfx wfy
exists β¨_, nodeβ©
exists Ξ» x => (kβ x).1
exists Ξ» x => (kβ x).1
constructor
. cases hix
have hnx: nx = node := by
apply congrArg Sigma.fst hβ
cases hnx
have hβ := Sigma.snd_equals _ _ _ hβ
rw [β hβ]
rfl
. constructor
. cases hiy
have hny: ny = node := by
apply congrArg Sigma.fst hβ
cases hny
have hβ := Sigma.snd_equals _ _ _ hβ
rw [β hβ]
rfl
. intro a
exists C.N i node a
simp only [toContainer] at a
exists (by
cases hix
have : nx = node := by
apply congrArg Sigma.fst hβ
cases this
have hβ := Sigma.snd_equals _ _ _ hβ
have wfx' := wfx' a
cases hβ
exact wfx'
)
exists (by
cases hiy
have : ny = node := by
apply congrArg Sigma.fst hβ
cases this
have hβ := Sigma.snd_equals _ _ _ hβ
have wfy' := wfy' a
cases hβ
exact 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 i node), R (N C i 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 i node), R (N C i 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 i node), R (N C i 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 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 i node), R (N C i 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 i node), R (N C i 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 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 i node), R (N C i 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 i node), R (N C i 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 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 i node), R (N C i 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 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 i node), R (N C i 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 i node), R (N C i 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 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 i node), R (N C i 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 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 i node), R (N C i 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 i node), R (N C i 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | have β¨node, 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 i node), R (N C i 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | let ix := (Container.M.destruct x).1.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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
β’ β 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | let nx := (Container.M.destruct x).1.2 | 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
β’ β 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
β’ β 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | let kx := (Container.M.destruct x).2 | 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
β’ β 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
β’ β 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | let iy := (Container.M.destruct y).1.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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
β’ β 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
β’ β 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | let ny := (Container.M.destruct y).1.2 | 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
β’ β 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
β’ β 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | let ky := (Container.M.destruct y).2 | 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
β’ β 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
β’ β 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | have hix := index_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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
β’ β 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct β{ val := x, property := wfx }).fst.fst
β’ β 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | have hiy := index_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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct β{ val := x, property := wfx }).fst.fst
β’ β 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct β{ val := x, property := wfx }).fst.fst
hiy : i = (Container.M.destruct β{ val := y, property := wfy }).fst.fst
β’ β 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | have wfx' : β a:B C ix nx, WellFormed (C.N ix nx a) (kx a) := 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct β{ val := x, property := wfx }).fst.fst
hiy : i = (Container.M.destruct β{ val := y, property := wfy }).fst.fst
β’ β 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct β{ val := x, property := wfx }).fst.fst
hiy : i = (Container.M.destruct β{ val := y, property := wfy }).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
β’ β 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | have wfy' : β a:B C iy ny, WellFormed (C.N iy ny a) (ky a) := 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct β{ val := x, property := wfx }).fst.fst
hiy : i = (Container.M.destruct β{ val := y, property := wfy }).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
β’ β 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct β{ val := x, property := wfx }).fst.fst
hiy : i = (Container.M.destruct β{ val := y, property := wfy }).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ β 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | simp only at hix hiy wfx 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct β{ val := x, property := wfx }).fst.fst
hiy : i = (Container.M.destruct β{ val := y, property := wfy }).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ β 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ β 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ β 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ β kβ kβ,
Container.M.destruct x = { fst := { fst := i, snd := node }, snd := kβ } β§
Container.M.destruct y = { fst := { fst := i, snd := node }, snd := kβ } β§
β (i : Container.B (toContainer C) { fst := i, snd := 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/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ β kβ kβ,
Container.M.destruct x = { fst := { fst := i, snd := node }, snd := kβ } β§
Container.M.destruct y = { fst := { fst := i, snd := node }, snd := kβ } β§
β (i : Container.B (toContainer C) { fst := i, snd := 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ β kβ,
Container.M.destruct x = { fst := { fst := i, snd := node }, snd := fun x => β(kβ x) } β§
Container.M.destruct y = { fst := { fst := i, snd := node }, snd := kβ } β§
β (i_1 : Container.B (toContainer C) { fst := i, snd := node }),
β i_2 wfx wfy, R i_2 { val := (fun x => β(kβ x)) i_1, property := wfx } { val := kβ i_1, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ β kβ,
Container.M.destruct x = { fst := { fst := i, snd := node }, snd := fun x => β(kβ x) } β§
Container.M.destruct y = { fst := { fst := i, snd := node }, snd := kβ } β§
β (i_1 : Container.B (toContainer C) { fst := i, snd := node }),
β i_2 wfx wfy, R i_2 { val := (fun x => β(kβ x)) 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ Container.M.destruct x = { fst := { fst := i, snd := node }, snd := fun x => β(kβ x) } β§
Container.M.destruct y = { fst := { fst := i, snd := node }, snd := fun x => β(kβ x) } β§
β (i_1 : Container.B (toContainer C) { fst := i, snd := node }),
β i_2 wfx wfy,
R i_2 { val := (fun x => β(kβ x)) i_1, property := wfx } { val := (fun x => β(kβ x)) i_1, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | constructor | 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ Container.M.destruct x = { fst := { fst := i, snd := node }, snd := fun x => β(kβ x) } β§
Container.M.destruct y = { fst := { fst := i, snd := node }, snd := fun x => β(kβ x) } β§
β (i_1 : Container.B (toContainer C) { fst := i, snd := node }),
β i_2 wfx wfy,
R i_2 { val := (fun x => β(kβ x)) i_1, property := wfx } { val := (fun x => β(kβ x)) i_1, property := wfy } | case hβ.left
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ Container.M.destruct x = { fst := { fst := i, snd := node }, snd := fun x => β(kβ x) }
case hβ.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ Container.M.destruct y = { fst := { fst := i, snd := node }, snd := fun x => β(kβ x) } β§
β (i_1 : Container.B (toContainer C) { fst := i, snd := node }),
β i_2 wfx wfy,
R i_2 { val := (fun x => β(kβ x)) i_1, property := wfx } { val := (fun x => β(kβ x)) i_1, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | . cases hix
have hnx: nx = node := by
apply congrArg Sigma.fst hβ
cases hnx
have hβ := Sigma.snd_equals _ _ _ hβ
rw [β hβ]
rfl | case hβ.left
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ Container.M.destruct x = { fst := { fst := i, snd := node }, snd := fun x => β(kβ x) }
case hβ.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ Container.M.destruct y = { fst := { fst := i, snd := node }, snd := fun x => β(kβ x) } β§
β (i_1 : Container.B (toContainer C) { fst := i, snd := node }),
β i_2 wfx wfy,
R i_2 { val := (fun x => β(kβ x)) i_1, property := wfx } { val := (fun x => β(kβ x)) i_1, property := wfy } | case hβ.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ Container.M.destruct y = { fst := { fst := i, snd := node }, snd := fun x => β(kβ x) } β§
β (i_1 : Container.B (toContainer C) { fst := i, snd := node }),
β i_2 wfx wfy,
R i_2 { val := (fun x => β(kβ x)) i_1, property := wfx } { val := (fun x => β(kβ x)) i_1, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | . constructor
. cases hiy
have hny: ny = node := by
apply congrArg Sigma.fst hβ
cases hny
have hβ := Sigma.snd_equals _ _ _ hβ
rw [β hβ]
rfl
. intro a
exists C.N i node a
simp only [toContainer] at a
exists (by
cases hix
have : nx = node := by
apply congrArg Sigma.fst hβ
cases this
have hβ := Sigma.snd_equals _ _ _ hβ
have wfx' := wfx' a
cases hβ
exact wfx'
)
exists (by
cases hiy
have : ny = node := by
apply congrArg Sigma.fst hβ
cases this
have hβ := Sigma.snd_equals _ _ _ hβ
have wfy' := wfy' a
cases hβ
exact wfy'
)
exact hβ a | case hβ.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ Container.M.destruct y = { fst := { fst := i, snd := node }, snd := fun x => β(kβ x) } β§
β (i_1 : Container.B (toContainer C) { fst := i, snd := node }),
β i_2 wfx wfy,
R i_2 { val := (fun x => β(kβ x)) i_1, property := wfx } { val := (fun x => β(kβ x)) i_1, property := wfy } | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | cases hix | case hβ.left
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ Container.M.destruct x = { fst := { fst := i, snd := node }, snd := fun x => β(kβ x) } | case hβ.left.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct x).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst node) β M C (N C (Container.M.destruct x).fst.fst node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst node), R (N C (Container.M.destruct x).fst.fst node z) (kβ z) (kβ z)
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
β’ Container.M.destruct x =
{ fst := { fst := (Container.M.destruct x).fst.fst, snd := node }, snd := fun x_1 => β(kβ x_1) } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | have hnx: nx = node := by
apply congrArg Sigma.fst hβ | case hβ.left.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct x).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst node) β M C (N C (Container.M.destruct x).fst.fst node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst node), R (N C (Container.M.destruct x).fst.fst node z) (kβ z) (kβ z)
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
β’ Container.M.destruct x =
{ fst := { fst := (Container.M.destruct x).fst.fst, snd := node }, snd := fun x_1 => β(kβ x_1) } | case hβ.left.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct x).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst node) β M C (N C (Container.M.destruct x).fst.fst node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst node), R (N C (Container.M.destruct x).fst.fst node z) (kβ z) (kβ z)
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
hnx : nx = node
β’ Container.M.destruct x =
{ fst := { fst := (Container.M.destruct x).fst.fst, snd := node }, snd := fun x_1 => β(kβ x_1) } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | cases hnx | case hβ.left.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct x).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst node) β M C (N C (Container.M.destruct x).fst.fst node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst node), R (N C (Container.M.destruct x).fst.fst node z) (kβ z) (kβ z)
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
hnx : nx = node
β’ Container.M.destruct x =
{ fst := { fst := (Container.M.destruct x).fst.fst, snd := node }, snd := fun x_1 => β(kβ x_1) } | case hβ.left.refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst nx) β M C (N C (Container.M.destruct x).fst.fst nx y)
hβ : destruct { val := x, property := wfx } = { fst := nx, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := nx, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst nx), R (N C (Container.M.destruct x).fst.fst nx z) (kβ z) (kβ z)
β’ Container.M.destruct x =
{ fst := { fst := (Container.M.destruct x).fst.fst, snd := nx }, snd := fun x_1 => β(kβ x_1) } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | have hβ := Sigma.snd_equals _ _ _ hβ | case hβ.left.refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst nx) β M C (N C (Container.M.destruct x).fst.fst nx y)
hβ : destruct { val := x, property := wfx } = { fst := nx, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := nx, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst nx), R (N C (Container.M.destruct x).fst.fst nx z) (kβ z) (kβ z)
β’ Container.M.destruct x =
{ fst := { fst := (Container.M.destruct x).fst.fst, snd := nx }, snd := fun x_1 => β(kβ x_1) } | case hβ.left.refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst nx) β M C (N C (Container.M.destruct x).fst.fst nx y)
hββ : destruct { val := x, property := wfx } = { fst := nx, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := nx, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst nx), R (N C (Container.M.destruct x).fst.fst nx z) (kβ z) (kβ z)
hβ : (destruct { val := x, property := wfx }).snd = kβ
β’ Container.M.destruct x =
{ fst := { fst := (Container.M.destruct x).fst.fst, snd := nx }, snd := fun x_1 => β(kβ x_1) } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | rw [β hβ] | case hβ.left.refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst nx) β M C (N C (Container.M.destruct x).fst.fst nx y)
hββ : destruct { val := x, property := wfx } = { fst := nx, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := nx, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst nx), R (N C (Container.M.destruct x).fst.fst nx z) (kβ z) (kβ z)
hβ : (destruct { val := x, property := wfx }).snd = kβ
β’ Container.M.destruct x =
{ fst := { fst := (Container.M.destruct x).fst.fst, snd := nx }, snd := fun x_1 => β(kβ x_1) } | case hβ.left.refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst nx) β M C (N C (Container.M.destruct x).fst.fst nx y)
hββ : destruct { val := x, property := wfx } = { fst := nx, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := nx, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst nx), R (N C (Container.M.destruct x).fst.fst nx z) (kβ z) (kβ z)
hβ : (destruct { val := x, property := wfx }).snd = kβ
β’ Container.M.destruct x =
{ fst := { fst := (Container.M.destruct x).fst.fst, snd := nx },
snd := fun x_1 => β(Sigma.snd (destruct { val := x, property := wfx }) x_1) } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | rfl | case hβ.left.refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst nx) β M C (N C (Container.M.destruct x).fst.fst nx y)
hββ : destruct { val := x, property := wfx } = { fst := nx, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := nx, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst nx), R (N C (Container.M.destruct x).fst.fst nx z) (kβ z) (kβ z)
hβ : (destruct { val := x, property := wfx }).snd = kβ
β’ Container.M.destruct x =
{ fst := { fst := (Container.M.destruct x).fst.fst, snd := nx },
snd := fun x_1 => β(Sigma.snd (destruct { val := x, property := wfx }) x_1) } | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | apply congrArg Sigma.fst 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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct x).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst node) β M C (N C (Container.M.destruct x).fst.fst node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst node), R (N C (Container.M.destruct x).fst.fst node z) (kβ z) (kβ z)
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
β’ nx = node | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | constructor | case hβ.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ Container.M.destruct y = { fst := { fst := i, snd := node }, snd := fun x => β(kβ x) } β§
β (i_1 : Container.B (toContainer C) { fst := i, snd := node }),
β i_2 wfx wfy,
R i_2 { val := (fun x => β(kβ x)) i_1, property := wfx } { val := (fun x => β(kβ x)) i_1, property := wfy } | case hβ.right.left
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ Container.M.destruct y = { fst := { fst := i, snd := node }, snd := fun x => β(kβ x) }
case hβ.right.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ β (i_1 : Container.B (toContainer C) { fst := i, snd := node }),
β i_2 wfx wfy,
R i_2 { val := (fun x => β(kβ x)) i_1, property := wfx } { val := (fun x => β(kβ x)) i_1, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | . cases hiy
have hny: ny = node := by
apply congrArg Sigma.fst hβ
cases hny
have hβ := Sigma.snd_equals _ _ _ hβ
rw [β hβ]
rfl | case hβ.right.left
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ Container.M.destruct y = { fst := { fst := i, snd := node }, snd := fun x => β(kβ x) }
case hβ.right.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ β (i_1 : Container.B (toContainer C) { fst := i, snd := node }),
β i_2 wfx wfy,
R i_2 { val := (fun x => β(kβ x)) i_1, property := wfx } { val := (fun x => β(kβ x)) i_1, property := wfy } | case hβ.right.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ β (i_1 : Container.B (toContainer C) { fst := i, snd := node }),
β i_2 wfx wfy,
R i_2 { val := (fun x => β(kβ x)) i_1, property := wfx } { val := (fun x => β(kβ x)) i_1, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | . intro a
exists C.N i node a
simp only [toContainer] at a
exists (by
cases hix
have : nx = node := by
apply congrArg Sigma.fst hβ
cases this
have hβ := Sigma.snd_equals _ _ _ hβ
have wfx' := wfx' a
cases hβ
exact wfx'
)
exists (by
cases hiy
have : ny = node := by
apply congrArg Sigma.fst hβ
cases this
have hβ := Sigma.snd_equals _ _ _ hβ
have wfy' := wfy' a
cases hβ
exact wfy'
)
exact hβ a | case hβ.right.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ β (i_1 : Container.B (toContainer C) { fst := i, snd := node }),
β i_2 wfx wfy,
R i_2 { val := (fun x => β(kβ x)) i_1, property := wfx } { val := (fun x => β(kβ x)) i_1, property := wfy } | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | cases hiy | case hβ.right.left
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ Container.M.destruct y = { fst := { fst := i, snd := node }, snd := fun x => β(kβ x) } | case hβ.right.left.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct y).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst node) β M C (N C (Container.M.destruct y).fst.fst node y_1)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst node), R (N C (Container.M.destruct y).fst.fst node z) (kβ z) (kβ z)
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
β’ Container.M.destruct y = { fst := { fst := (Container.M.destruct y).fst.fst, snd := node }, snd := fun x => β(kβ x) } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | have hny: ny = node := by
apply congrArg Sigma.fst hβ | case hβ.right.left.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct y).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst node) β M C (N C (Container.M.destruct y).fst.fst node y_1)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst node), R (N C (Container.M.destruct y).fst.fst node z) (kβ z) (kβ z)
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
β’ Container.M.destruct y = { fst := { fst := (Container.M.destruct y).fst.fst, snd := node }, snd := fun x => β(kβ x) } | case hβ.right.left.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct y).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst node) β M C (N C (Container.M.destruct y).fst.fst node y_1)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst node), R (N C (Container.M.destruct y).fst.fst node z) (kβ z) (kβ z)
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
hny : ny = node
β’ Container.M.destruct y = { fst := { fst := (Container.M.destruct y).fst.fst, snd := node }, snd := fun x => β(kβ x) } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | cases hny | case hβ.right.left.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct y).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst node) β M C (N C (Container.M.destruct y).fst.fst node y_1)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst node), R (N C (Container.M.destruct y).fst.fst node z) (kβ z) (kβ z)
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
hny : ny = node
β’ Container.M.destruct y = { fst := { fst := (Container.M.destruct y).fst.fst, snd := node }, snd := fun x => β(kβ x) } | case hβ.right.left.refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst ny) β M C (N C (Container.M.destruct y).fst.fst ny y_1)
hβ : destruct { val := x, property := wfx } = { fst := ny, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := ny, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst ny), R (N C (Container.M.destruct y).fst.fst ny z) (kβ z) (kβ z)
β’ Container.M.destruct y = { fst := { fst := (Container.M.destruct y).fst.fst, snd := ny }, snd := fun x => β(kβ x) } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | have hβ := Sigma.snd_equals _ _ _ hβ | case hβ.right.left.refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst ny) β M C (N C (Container.M.destruct y).fst.fst ny y_1)
hβ : destruct { val := x, property := wfx } = { fst := ny, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := ny, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst ny), R (N C (Container.M.destruct y).fst.fst ny z) (kβ z) (kβ z)
β’ Container.M.destruct y = { fst := { fst := (Container.M.destruct y).fst.fst, snd := ny }, snd := fun x => β(kβ x) } | case hβ.right.left.refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst ny) β M C (N C (Container.M.destruct y).fst.fst ny y_1)
hβ : destruct { val := x, property := wfx } = { fst := ny, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := ny, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst ny), R (N C (Container.M.destruct y).fst.fst ny z) (kβ z) (kβ z)
hβ : (destruct { val := y, property := wfy }).snd = kβ
β’ Container.M.destruct y = { fst := { fst := (Container.M.destruct y).fst.fst, snd := ny }, snd := fun x => β(kβ x) } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | rw [β hβ] | case hβ.right.left.refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst ny) β M C (N C (Container.M.destruct y).fst.fst ny y_1)
hβ : destruct { val := x, property := wfx } = { fst := ny, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := ny, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst ny), R (N C (Container.M.destruct y).fst.fst ny z) (kβ z) (kβ z)
hβ : (destruct { val := y, property := wfy }).snd = kβ
β’ Container.M.destruct y = { fst := { fst := (Container.M.destruct y).fst.fst, snd := ny }, snd := fun x => β(kβ x) } | case hβ.right.left.refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst ny) β M C (N C (Container.M.destruct y).fst.fst ny y_1)
hβ : destruct { val := x, property := wfx } = { fst := ny, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := ny, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst ny), R (N C (Container.M.destruct y).fst.fst ny z) (kβ z) (kβ z)
hβ : (destruct { val := y, property := wfy }).snd = kβ
β’ Container.M.destruct y =
{ fst := { fst := (Container.M.destruct y).fst.fst, snd := ny },
snd := fun x => β(Sigma.snd (destruct { val := y, property := wfy }) x) } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | rfl | case hβ.right.left.refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst ny) β M C (N C (Container.M.destruct y).fst.fst ny y_1)
hβ : destruct { val := x, property := wfx } = { fst := ny, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := ny, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst ny), R (N C (Container.M.destruct y).fst.fst ny z) (kβ z) (kβ z)
hβ : (destruct { val := y, property := wfy }).snd = kβ
β’ Container.M.destruct y =
{ fst := { fst := (Container.M.destruct y).fst.fst, snd := ny },
snd := fun x => β(Sigma.snd (destruct { val := y, property := wfy }) x) } | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | apply congrArg Sigma.fst 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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct y).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst node) β M C (N C (Container.M.destruct y).fst.fst node y_1)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst node), R (N C (Container.M.destruct y).fst.fst node z) (kβ z) (kβ z)
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
β’ ny = node | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | intro a | case hβ.right.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
β’ β (i_1 : Container.B (toContainer C) { fst := i, snd := node }),
β i_2 wfx wfy,
R i_2 { val := (fun x => β(kβ x)) i_1, property := wfx } { val := (fun x => β(kβ x)) i_1, property := wfy } | case hβ.right.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
a : Container.B (toContainer C) { fst := i, snd := node }
β’ β i_1 wfx wfy, R i_1 { val := (fun x => β(kβ x)) a, property := wfx } { val := (fun x => β(kβ x)) a, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | exists C.N i node a | case hβ.right.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
a : Container.B (toContainer C) { fst := i, snd := node }
β’ β i_1 wfx wfy, R i_1 { val := (fun x => β(kβ x)) a, property := wfx } { val := (fun x => β(kβ x)) a, property := wfy } | case hβ.right.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
a : Container.B (toContainer C) { fst := i, snd := node }
β’ β wfx wfy,
R (N C i node a) { val := (fun x => β(kβ x)) a, property := wfx } { val := (fun x => β(kβ x)) a, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | simp only [toContainer] at a | case hβ.right.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
a : Container.B (toContainer C) { fst := i, snd := node }
β’ β wfx wfy,
R (N C i node a) { val := (fun x => β(kβ x)) a, property := wfx } { val := (fun x => β(kβ x)) a, property := wfy } | case hβ.right.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
a : B C i node
β’ β wfx wfy,
R (N C i node a) { val := (fun x => β(kβ x)) a, property := wfx } { val := (fun x => β(kβ x)) a, property := wfy } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | exists (by
cases hix
have : nx = node := by
apply congrArg Sigma.fst hβ
cases this
have hβ := Sigma.snd_equals _ _ _ hβ
have wfx' := wfx' a
cases hβ
exact wfx'
) | case hβ.right.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
a : B C i node
β’ β wfx wfy,
R (N C i node a) { val := (fun x => β(kβ x)) a, property := wfx } { val := (fun x => β(kβ x)) a, property := wfy } | case hβ.right.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
a : B C i node
β’ β wfy_1,
R (N C i node a) { val := (fun x => β(kβ x)) a, property := (_ : WellFormed (N C i node a) ((fun x => β(kβ x)) a)) }
{ val := (fun x => β(kβ x)) a, property := wfy_1 } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | exists (by
cases hiy
have : ny = node := by
apply congrArg Sigma.fst hβ
cases this
have hβ := Sigma.snd_equals _ _ _ hβ
have wfy' := wfy' a
cases hβ
exact wfy'
) | case hβ.right.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
a : B C i node
β’ β wfy_1,
R (N C i node a) { val := (fun x => β(kβ x)) a, property := (_ : WellFormed (N C i node a) ((fun x => β(kβ x)) a)) }
{ val := (fun x => β(kβ x)) a, property := wfy_1 } | case hβ.right.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
a : B C i node
β’ R (N C i node a) { val := (fun x => β(kβ x)) a, property := (_ : WellFormed (N C i node a) ((fun x => β(kβ x)) a)) }
{ val := (fun x => β(kβ x)) a, property := (_ : WellFormed (N C i node a) ((fun x => β(kβ x)) a)) } |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | exact hβ a | case hβ.right.right
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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
a : B C i node
β’ R (N C i node a) { val := (fun x => β(kβ x)) a, property := (_ : WellFormed (N C i node a) ((fun x => β(kβ x)) a)) }
{ val := (fun x => β(kβ x)) a, property := (_ : WellFormed (N C i node a) ((fun x => β(kβ x)) a)) } | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | cases hix | 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
a : B C i node
β’ WellFormed (N C i node a) ((fun x => β(kβ x)) a) | 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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct x).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst node) β M C (N C (Container.M.destruct x).fst.fst node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst node), R (N C (Container.M.destruct x).fst.fst node z) (kβ z) (kβ z)
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
a : B C (Container.M.destruct x).fst.fst node
β’ WellFormed (N C (Container.M.destruct x).fst.fst node a) ((fun x_1 => β(kβ x_1)) a) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | have : nx = node := by
apply congrArg Sigma.fst hβ | 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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct x).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst node) β M C (N C (Container.M.destruct x).fst.fst node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst node), R (N C (Container.M.destruct x).fst.fst node z) (kβ z) (kβ z)
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
a : B C (Container.M.destruct x).fst.fst node
β’ WellFormed (N C (Container.M.destruct x).fst.fst node a) ((fun x_1 => β(kβ x_1)) a) | 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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct x).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst node) β M C (N C (Container.M.destruct x).fst.fst node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst node), R (N C (Container.M.destruct x).fst.fst node z) (kβ z) (kβ z)
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
a : B C (Container.M.destruct x).fst.fst node
this : nx = node
β’ WellFormed (N C (Container.M.destruct x).fst.fst node a) ((fun x_1 => β(kβ x_1)) a) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | cases this | 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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct x).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst node) β M C (N C (Container.M.destruct x).fst.fst node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst node), R (N C (Container.M.destruct x).fst.fst node z) (kβ z) (kβ z)
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
a : B C (Container.M.destruct x).fst.fst node
this : nx = node
β’ WellFormed (N C (Container.M.destruct x).fst.fst node a) ((fun x_1 => β(kβ x_1)) a) | case refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst nx) β M C (N C (Container.M.destruct x).fst.fst nx y)
hβ : destruct { val := x, property := wfx } = { fst := nx, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := nx, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst nx), R (N C (Container.M.destruct x).fst.fst nx z) (kβ z) (kβ z)
a : B C (Container.M.destruct x).fst.fst nx
β’ WellFormed (N C (Container.M.destruct x).fst.fst nx a) ((fun x_1 => β(kβ x_1)) a) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | have hβ := Sigma.snd_equals _ _ _ hβ | case refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst nx) β M C (N C (Container.M.destruct x).fst.fst nx y)
hβ : destruct { val := x, property := wfx } = { fst := nx, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := nx, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst nx), R (N C (Container.M.destruct x).fst.fst nx z) (kβ z) (kβ z)
a : B C (Container.M.destruct x).fst.fst nx
β’ WellFormed (N C (Container.M.destruct x).fst.fst nx a) ((fun x_1 => β(kβ x_1)) a) | case refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst nx) β M C (N C (Container.M.destruct x).fst.fst nx y)
hββ : destruct { val := x, property := wfx } = { fst := nx, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := nx, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst nx), R (N C (Container.M.destruct x).fst.fst nx z) (kβ z) (kβ z)
a : B C (Container.M.destruct x).fst.fst nx
hβ : (destruct { val := x, property := wfx }).snd = kβ
β’ WellFormed (N C (Container.M.destruct x).fst.fst nx a) ((fun x_1 => β(kβ x_1)) a) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | have wfx' := wfx' a | case refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst nx) β M C (N C (Container.M.destruct x).fst.fst nx y)
hββ : destruct { val := x, property := wfx } = { fst := nx, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := nx, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst nx), R (N C (Container.M.destruct x).fst.fst nx z) (kβ z) (kβ z)
a : B C (Container.M.destruct x).fst.fst nx
hβ : (destruct { val := x, property := wfx }).snd = kβ
β’ WellFormed (N C (Container.M.destruct x).fst.fst nx a) ((fun x_1 => β(kβ x_1)) a) | case refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx'β : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst nx) β M C (N C (Container.M.destruct x).fst.fst nx y)
hββ : destruct { val := x, property := wfx } = { fst := nx, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := nx, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst nx), R (N C (Container.M.destruct x).fst.fst nx z) (kβ z) (kβ z)
a : B C (Container.M.destruct x).fst.fst nx
hβ : (destruct { val := x, property := wfx }).snd = kβ
wfx' : WellFormed (N C ix nx a) (kx a)
β’ WellFormed (N C (Container.M.destruct x).fst.fst nx a) ((fun x_1 => β(kβ x_1)) a) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | cases hβ | case refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx'β : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst nx) β M C (N C (Container.M.destruct x).fst.fst nx y)
hββ : destruct { val := x, property := wfx } = { fst := nx, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := nx, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst nx), R (N C (Container.M.destruct x).fst.fst nx z) (kβ z) (kβ z)
a : B C (Container.M.destruct x).fst.fst nx
hβ : (destruct { val := x, property := wfx }).snd = kβ
wfx' : WellFormed (N C ix nx a) (kx a)
β’ WellFormed (N C (Container.M.destruct x).fst.fst nx a) ((fun x_1 => β(kβ x_1)) a) | case refl.refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx'β : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
kβ : (y : B C (Container.M.destruct x).fst.fst nx) β M C (N C (Container.M.destruct x).fst.fst nx y)
hβ : destruct { val := y, property := wfy } = { fst := nx, snd := kβ }
a : B C (Container.M.destruct x).fst.fst nx
wfx' : WellFormed (N C ix nx a) (kx a)
hβ : destruct { val := x, property := wfx } = { fst := nx, snd := (destruct { val := x, property := wfx }).snd }
hβ :
β (z : B C (Container.M.destruct x).fst.fst nx),
R (N C (Container.M.destruct x).fst.fst nx z) (Sigma.snd (destruct { val := x, property := wfx }) z) (kβ z)
β’ WellFormed (N C (Container.M.destruct x).fst.fst nx a)
((fun x_1 => β(Sigma.snd (destruct { val := x, property := wfx }) x_1)) a) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | exact wfx' | case refl.refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx'β : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
kβ : (y : B C (Container.M.destruct x).fst.fst nx) β M C (N C (Container.M.destruct x).fst.fst nx y)
hβ : destruct { val := y, property := wfy } = { fst := nx, snd := kβ }
a : B C (Container.M.destruct x).fst.fst nx
wfx' : WellFormed (N C ix nx a) (kx a)
hβ : destruct { val := x, property := wfx } = { fst := nx, snd := (destruct { val := x, property := wfx }).snd }
hβ :
β (z : B C (Container.M.destruct x).fst.fst nx),
R (N C (Container.M.destruct x).fst.fst nx z) (Sigma.snd (destruct { val := x, property := wfx }) z) (kβ z)
β’ WellFormed (N C (Container.M.destruct x).fst.fst nx a)
((fun x_1 => β(Sigma.snd (destruct { val := x, property := wfx }) x_1)) a) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | apply congrArg Sigma.fst 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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct x).fst.fst x
wfy : WellFormed (Container.M.destruct x).fst.fst y
r : R (Container.M.destruct x).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct x).fst.fst
kβ kβ : (y : B C (Container.M.destruct x).fst.fst node) β M C (N C (Container.M.destruct x).fst.fst node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct x).fst.fst node), R (N C (Container.M.destruct x).fst.fst node z) (kβ z) (kβ z)
hiy : (Container.M.destruct x).fst.fst = (Container.M.destruct y).fst.fst
a : B C (Container.M.destruct x).fst.fst node
β’ nx = node | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | cases hiy | 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 i node), R (N C i 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 : A C i
kβ kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C i node), R (N C i node z) (kβ z) (kβ z)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
hix : i = (Container.M.destruct x).fst.fst
hiy : i = (Container.M.destruct y).fst.fst
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
a : B C i node
β’ WellFormed (N C i node a) ((fun x => β(kβ x)) a) | 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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct y).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst node) β M C (N C (Container.M.destruct y).fst.fst node y_1)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst node), R (N C (Container.M.destruct y).fst.fst node z) (kβ z) (kβ z)
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
a : B C (Container.M.destruct y).fst.fst node
β’ WellFormed (N C (Container.M.destruct y).fst.fst node a) ((fun x => β(kβ x)) a) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | have : ny = node := by
apply congrArg Sigma.fst hβ | 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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct y).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst node) β M C (N C (Container.M.destruct y).fst.fst node y_1)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst node), R (N C (Container.M.destruct y).fst.fst node z) (kβ z) (kβ z)
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
a : B C (Container.M.destruct y).fst.fst node
β’ WellFormed (N C (Container.M.destruct y).fst.fst node a) ((fun x => β(kβ x)) a) | 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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct y).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst node) β M C (N C (Container.M.destruct y).fst.fst node y_1)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst node), R (N C (Container.M.destruct y).fst.fst node z) (kβ z) (kβ z)
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
a : B C (Container.M.destruct y).fst.fst node
this : ny = node
β’ WellFormed (N C (Container.M.destruct y).fst.fst node a) ((fun x => β(kβ x)) a) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | cases this | 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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct y).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst node) β M C (N C (Container.M.destruct y).fst.fst node y_1)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst node), R (N C (Container.M.destruct y).fst.fst node z) (kβ z) (kβ z)
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
a : B C (Container.M.destruct y).fst.fst node
this : ny = node
β’ WellFormed (N C (Container.M.destruct y).fst.fst node a) ((fun x => β(kβ x)) a) | case refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst ny) β M C (N C (Container.M.destruct y).fst.fst ny y_1)
hβ : destruct { val := x, property := wfx } = { fst := ny, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := ny, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst ny), R (N C (Container.M.destruct y).fst.fst ny z) (kβ z) (kβ z)
a : B C (Container.M.destruct y).fst.fst ny
β’ WellFormed (N C (Container.M.destruct y).fst.fst ny a) ((fun x => β(kβ x)) a) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | have hβ := Sigma.snd_equals _ _ _ hβ | case refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst ny) β M C (N C (Container.M.destruct y).fst.fst ny y_1)
hβ : destruct { val := x, property := wfx } = { fst := ny, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := ny, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst ny), R (N C (Container.M.destruct y).fst.fst ny z) (kβ z) (kβ z)
a : B C (Container.M.destruct y).fst.fst ny
β’ WellFormed (N C (Container.M.destruct y).fst.fst ny a) ((fun x => β(kβ x)) a) | case refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst ny) β M C (N C (Container.M.destruct y).fst.fst ny y_1)
hβ : destruct { val := x, property := wfx } = { fst := ny, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := ny, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst ny), R (N C (Container.M.destruct y).fst.fst ny z) (kβ z) (kβ z)
a : B C (Container.M.destruct y).fst.fst ny
hβ : (destruct { val := y, property := wfy }).snd = kβ
β’ WellFormed (N C (Container.M.destruct y).fst.fst ny a) ((fun x => β(kβ x)) a) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | have wfy' := wfy' a | case refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst ny) β M C (N C (Container.M.destruct y).fst.fst ny y_1)
hβ : destruct { val := x, property := wfx } = { fst := ny, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := ny, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst ny), R (N C (Container.M.destruct y).fst.fst ny z) (kβ z) (kβ z)
a : B C (Container.M.destruct y).fst.fst ny
hβ : (destruct { val := y, property := wfy }).snd = kβ
β’ WellFormed (N C (Container.M.destruct y).fst.fst ny a) ((fun x => β(kβ x)) a) | case refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy'β : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst ny) β M C (N C (Container.M.destruct y).fst.fst ny y_1)
hβ : destruct { val := x, property := wfx } = { fst := ny, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := ny, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst ny), R (N C (Container.M.destruct y).fst.fst ny z) (kβ z) (kβ z)
a : B C (Container.M.destruct y).fst.fst ny
hβ : (destruct { val := y, property := wfy }).snd = kβ
wfy' : WellFormed (N C iy ny a) (ky a)
β’ WellFormed (N C (Container.M.destruct y).fst.fst ny a) ((fun x => β(kβ x)) a) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | cases hβ | case refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy'β : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst ny) β M C (N C (Container.M.destruct y).fst.fst ny y_1)
hβ : destruct { val := x, property := wfx } = { fst := ny, snd := kβ }
hββ : destruct { val := y, property := wfy } = { fst := ny, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst ny), R (N C (Container.M.destruct y).fst.fst ny z) (kβ z) (kβ z)
a : B C (Container.M.destruct y).fst.fst ny
hβ : (destruct { val := y, property := wfy }).snd = kβ
wfy' : WellFormed (N C iy ny a) (ky a)
β’ WellFormed (N C (Container.M.destruct y).fst.fst ny a) ((fun x => β(kβ x)) a) | case refl.refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy'β : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
kβ : (y_1 : B C (Container.M.destruct y).fst.fst ny) β M C (N C (Container.M.destruct y).fst.fst ny y_1)
hβ : destruct { val := x, property := wfx } = { fst := ny, snd := kβ }
a : B C (Container.M.destruct y).fst.fst ny
wfy' : WellFormed (N C iy ny a) (ky a)
hβ : destruct { val := y, property := wfy } = { fst := ny, snd := (destruct { val := y, property := wfy }).snd }
hβ :
β (z : B C (Container.M.destruct y).fst.fst ny),
R (N C (Container.M.destruct y).fst.fst ny z) (kβ z) (Sigma.snd (destruct { val := y, property := wfy }) z)
β’ WellFormed (N C (Container.M.destruct y).fst.fst ny a)
((fun x => β(Sigma.snd (destruct { val := y, property := wfy }) x)) a) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | exact wfy' | case refl.refl.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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy'β : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
kβ : (y_1 : B C (Container.M.destruct y).fst.fst ny) β M C (N C (Container.M.destruct y).fst.fst ny y_1)
hβ : destruct { val := x, property := wfx } = { fst := ny, snd := kβ }
a : B C (Container.M.destruct y).fst.fst ny
wfy' : WellFormed (N C iy ny a) (ky a)
hβ : destruct { val := y, property := wfy } = { fst := ny, snd := (destruct { val := y, property := wfy }).snd }
hβ :
β (z : B C (Container.M.destruct y).fst.fst ny),
R (N C (Container.M.destruct y).fst.fst ny z) (kβ z) (Sigma.snd (destruct { val := y, property := wfy }) z)
β’ WellFormed (N C (Container.M.destruct y).fst.fst ny a)
((fun x => β(Sigma.snd (destruct { val := y, property := wfy }) x)) a) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.bisim | [85, 1] | [162, 13] | apply congrArg Sigma.fst 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 i node), R (N C i 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)
ix : I := (Container.M.destruct x).fst.fst
nx : A C (Container.M.destruct x).fst.fst := (Container.M.destruct x).fst.snd
kx : Container.B (toContainer C) (Container.M.destruct x).fst β Container.M (toContainer C) :=
(Container.M.destruct x).snd
iy : I := (Container.M.destruct y).fst.fst
ny : A C (Container.M.destruct y).fst.fst := (Container.M.destruct y).fst.snd
ky : Container.B (toContainer C) (Container.M.destruct y).fst β Container.M (toContainer C) :=
(Container.M.destruct y).snd
wfx' : β (a : B C ix nx), WellFormed (N C ix nx a) (kx a)
wfy' : β (a : B C iy ny), WellFormed (N C iy ny a) (ky a)
wfx : WellFormed (Container.M.destruct y).fst.fst x
wfy : WellFormed (Container.M.destruct y).fst.fst y
r : R (Container.M.destruct y).fst.fst { val := x, property := wfx } { val := y, property := wfy }
node : A C (Container.M.destruct y).fst.fst
kβ kβ : (y_1 : B C (Container.M.destruct y).fst.fst node) β M C (N C (Container.M.destruct y).fst.fst node y_1)
hβ : destruct { val := x, property := wfx } = { fst := node, snd := kβ }
hβ : destruct { val := y, property := wfy } = { fst := node, snd := kβ }
hβ : β (z : B C (Container.M.destruct y).fst.fst node), R (N C (Container.M.destruct y).fst.fst node z) (kβ z) (kβ z)
hix : (Container.M.destruct y).fst.fst = (Container.M.destruct x).fst.fst
a : B C (Container.M.destruct y).fst.fst node
β’ ny = node | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.congr.coinduction | [55, 1] | [66, 13] | intro hβ i x y hβ | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
β’ (β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y) β β (i : I) (x y : M (C F) i), p i x y β congr F i x y | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
β’ congr F i x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.congr.coinduction | [55, 1] | [66, 13] | simp only [congr, pcongr] | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
β’ congr F i x y | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
β’ β(pgfp (precongr F)) β₯ i x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.congr.coinduction | [55, 1] | [66, 13] | have := (pgfp.coinduction (precongr F) p).2 | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
β’ β(pgfp (precongr F)) β₯ i x y | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
this : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
β’ β(pgfp (precongr F)) β₯ i x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.congr.coinduction | [55, 1] | [66, 13] | apply this | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
this : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
β’ β(pgfp (precongr F)) β₯ i x y | case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
this : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
β’ p β€ β(precongr F) (p β β(pgfp (precongr F)) p)
case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
this : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
β’ p i x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.congr.coinduction | [55, 1] | [66, 13] | have : p β€ p β pgfp (precongr F) p := by
simp | case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
this : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
β’ p β€ β(precongr F) (p β β(pgfp (precongr F)) p)
case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
this : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
β’ p i x y | case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
thisβ : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
this : p β€ p β β(pgfp (precongr F)) p
β’ p β€ β(precongr F) (p β β(pgfp (precongr F)) p)
case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
this : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
β’ p i x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.congr.coinduction | [55, 1] | [66, 13] | have := (precongr F).2 this | case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
thisβ : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
this : p β€ p β β(pgfp (precongr F)) p
β’ p β€ β(precongr F) (p β β(pgfp (precongr F)) p)
case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
this : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
β’ p i x y | case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
thisβΒΉ : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
thisβ : p β€ p β β(pgfp (precongr F)) p
this : β(precongr F) p β€ β(precongr F) (p β β(pgfp (precongr F)) p)
β’ p β€ β(precongr F) (p β β(pgfp (precongr F)) p)
case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
this : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
β’ p i x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.congr.coinduction | [55, 1] | [66, 13] | apply le_trans _ this | case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
thisβΒΉ : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
thisβ : p β€ p β β(pgfp (precongr F)) p
this : β(precongr F) p β€ β(precongr F) (p β β(pgfp (precongr F)) p)
β’ p β€ β(precongr F) (p β β(pgfp (precongr F)) p)
case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
this : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
β’ p i x y | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
thisβΒΉ : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
thisβ : p β€ p β β(pgfp (precongr F)) p
this : β(precongr F) p β€ β(precongr F) (p β β(pgfp (precongr F)) p)
β’ p β€ β(precongr F) p
case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
this : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
β’ p i x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.congr.coinduction | [55, 1] | [66, 13] | apply hβ | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
thisβΒΉ : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
thisβ : p β€ p β β(pgfp (precongr F)) p
this : β(precongr F) p β€ β(precongr F) (p β β(pgfp (precongr F)) p)
β’ p β€ β(precongr F) p
case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
this : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
β’ p i x y | case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
this : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
β’ p i x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.congr.coinduction | [55, 1] | [66, 13] | assumption | case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
this : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
β’ p i x y | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.congr.coinduction | [55, 1] | [66, 13] | simp | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
p : (i : I) β M (C F) i β M (C F) i β Prop
hβ : β (i : I) (x y : M (C F) i), p i x y β β(precongr F) p i x y
i : I
x y : M (C F) i
hβ : p i x y
this : p β€ β(precongr F) (p β β(pgfp (precongr F)) p) β p β€ β(pgfp (precongr F)) β₯
β’ p β€ p β β(pgfp (precongr F)) p | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.destruct_corec | [97, 1] | [103, 47] | simp only [IQPF.M.destruct, IQPF.M.corec, destruct.f, IContainer.M.destruct_corec, inst.abs_imap, inst.abs_repr] | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
Ξ± : I β Type uβ
f : (i : I) β Ξ± i β F Ξ± i
i : I
xβ : Ξ± i
β’ destruct (corec f xβ) = IFunctor.imap (fun i x => corec f x) (f i xβ) | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
Ξ± : I β Type uβ
f : (i : I) β Ξ± i β F Ξ± i
i : I
xβ : Ξ± i
β’ IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1)
(IFunctor.imap (fun i => IContainer.M.corec fun i x => repr (f i x)) (f i xβ)) =
IFunctor.imap (fun i x => Quot.mk (congr F i) (IContainer.M.corec (fun i x => repr (f i x)) x)) (f i xβ) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.destruct_corec | [97, 1] | [103, 47] | rw [βinst.abs_repr (f i xβ)] | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
Ξ± : I β Type uβ
f : (i : I) β Ξ± i β F Ξ± i
i : I
xβ : Ξ± i
β’ IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1)
(IFunctor.imap (fun i => IContainer.M.corec fun i x => repr (f i x)) (f i xβ)) =
IFunctor.imap (fun i x => Quot.mk (congr F i) (IContainer.M.corec (fun i x => repr (f i x)) x)) (f i xβ) | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
Ξ± : I β Type uβ
f : (i : I) β Ξ± i β F Ξ± i
i : I
xβ : Ξ± i
β’ IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1)
(IFunctor.imap (fun i => IContainer.M.corec fun i x => repr (f i x)) (abs (repr (f i xβ)))) =
IFunctor.imap (fun i x => Quot.mk (congr F i) (IContainer.M.corec (fun i x => repr (f i x)) x))
(abs (repr (f i xβ))) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.destruct_corec | [97, 1] | [103, 47] | cases repr (f i xβ) with
| mk n k =>
simp only [βinst.abs_imap, IContainer.Map] | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
Ξ± : I β Type uβ
f : (i : I) β Ξ± i β F Ξ± i
i : I
xβ : Ξ± i
β’ IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1)
(IFunctor.imap (fun i => IContainer.M.corec fun i x => repr (f i x)) (abs (repr (f i xβ)))) =
IFunctor.imap (fun i x => Quot.mk (congr F i) (IContainer.M.corec (fun i x => repr (f i x)) x))
(abs (repr (f i xβ))) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.destruct_corec | [97, 1] | [103, 47] | simp only [βinst.abs_imap, IContainer.Map] | case mk
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
Ξ± : I β Type uβ
f : (i : I) β Ξ± i β F Ξ± i
i : I
xβ : Ξ± i
n : IContainer.A (C F) i
k : (y : IContainer.B (C F) i n) β Ξ± (IContainer.N (C F) i n y)
β’ IFunctor.imap (fun x x_1 => Quot.mk (congr F x) x_1)
(IFunctor.imap (fun i => IContainer.M.corec fun i x => repr (f i x)) (abs { fst := n, snd := k })) =
IFunctor.imap (fun i x => Quot.mk (congr F i) (IContainer.M.corec (fun i x => repr (f i x)) x))
(abs { fst := n, snd := k }) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.imap_spec | [118, 1] | [124, 40] | conv =>
congr
<;> rw [βinst.abs_repr x] | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
i : I
Ξ± Ξ² Ξ³ : I β Type uβ
f : (i : I) β Ξ² i β Ξ³ i
g : (i : I) β Ξ± i β Ξ² i
x : F Ξ± i
β’ IFunctor.imap (fun i => f i β g i) x = IFunctor.imap f (IFunctor.imap g x) | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
i : I
Ξ± Ξ² Ξ³ : I β Type uβ
f : (i : I) β Ξ² i β Ξ³ i
g : (i : I) β Ξ± i β Ξ² i
x : F Ξ± i
β’ IFunctor.imap (fun i => f i β g i) (abs (repr x)) = IFunctor.imap f (IFunctor.imap g (abs (repr x))) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.imap_spec | [118, 1] | [124, 40] | cases repr x | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
i : I
Ξ± Ξ² Ξ³ : I β Type uβ
f : (i : I) β Ξ² i β Ξ³ i
g : (i : I) β Ξ± i β Ξ² i
x : F Ξ± i
β’ IFunctor.imap (fun i => f i β g i) (abs (repr x)) = IFunctor.imap f (IFunctor.imap g (abs (repr x))) | case mk
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
i : I
Ξ± Ξ² Ξ³ : I β Type uβ
f : (i : I) β Ξ² i β Ξ³ i
g : (i : I) β Ξ± i β Ξ² i
x : F Ξ± i
fstβ : IContainer.A (C F) i
sndβ : (y : IContainer.B (C F) i fstβ) β Ξ± (IContainer.N (C F) i fstβ y)
β’ IFunctor.imap (fun i => f i β g i) (abs { fst := fstβ, snd := sndβ }) =
IFunctor.imap f (IFunctor.imap g (abs { fst := fstβ, snd := sndβ })) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.imap_spec | [118, 1] | [124, 40] | simp [βinst.abs_imap, IContainer.Map] | case mk
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
i : I
Ξ± Ξ² Ξ³ : I β Type uβ
f : (i : I) β Ξ² i β Ξ³ i
g : (i : I) β Ξ± i β Ξ² i
x : F Ξ± i
fstβ : IContainer.A (C F) i
sndβ : (y : IContainer.B (C F) i fstβ) β Ξ± (IContainer.N (C F) i fstβ y)
β’ IFunctor.imap (fun i => f i β g i) (abs { fst := fstβ, snd := sndβ }) =
IFunctor.imap f (IFunctor.imap g (abs { fst := fstβ, snd := sndβ })) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IContainer.Map_spec | [126, 1] | [129, 24] | cases x | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
i : I
Ξ± Ξ² Ξ³ : I β Type uβ
f : (i : I) β Ξ² i β Ξ³ i
g : (i : I) β Ξ± i β Ξ² i
x : Obj (IQPF.C F) Ξ± i
β’ Map (fun i => f i β g i) x = Map f (Map g x) | case mk
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
i : I
Ξ± Ξ² Ξ³ : I β Type uβ
f : (i : I) β Ξ² i β Ξ³ i
g : (i : I) β Ξ± i β Ξ² i
fstβ : A (IQPF.C F) i
sndβ : (y : B (IQPF.C F) i fstβ) β Ξ± (N (IQPF.C F) i fstβ y)
β’ Map (fun i => f i β g i) { fst := fstβ, snd := sndβ } = Map f (Map g { fst := fstβ, snd := sndβ }) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IContainer.Map_spec | [126, 1] | [129, 24] | simp [IContainer.Map] | case mk
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
i : I
Ξ± Ξ² Ξ³ : I β Type uβ
f : (i : I) β Ξ² i β Ξ³ i
g : (i : I) β Ξ± i β Ξ² i
fstβ : A (IQPF.C F) i
sndβ : (y : B (IQPF.C F) i fstβ) β Ξ± (N (IQPF.C F) i fstβ y)
β’ Map (fun i => f i β g i) { fst := fstβ, snd := sndβ } = Map f (Map g { fst := fstβ, snd := sndβ }) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.bisim_lemma | [131, 1] | [183, 13] | intro i x | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
β’ β (i : I) (x y : M F i), r i x y β x = y | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
i : I
x : M F i
β’ β (y : M F i), r i x y β x = y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.bisim_lemma | [131, 1] | [183, 13] | apply Quot.inductionOn (motive := _) x | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
i : I
x : M F i
β’ β (y : M F i), r i x y β x = y | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
i : I
x : M F i
β’ β (a : IContainer.M (C F) i) (y : M F i), r i (Quot.mk (congr F i) a) y β Quot.mk (congr F i) a = y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.bisim_lemma | [131, 1] | [183, 13] | clear x | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
i : I
x : M F i
β’ β (a : IContainer.M (C F) i) (y : M F i), r i (Quot.mk (congr F i) a) y β Quot.mk (congr F i) a = y | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
i : I
β’ β (a : IContainer.M (C F) i) (y : M F i), r i (Quot.mk (congr F i) a) y β Quot.mk (congr F i) a = y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.bisim_lemma | [131, 1] | [183, 13] | intro x y | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
i : I
β’ β (a : IContainer.M (C F) i) (y : M F i), r i (Quot.mk (congr F i) a) y β Quot.mk (congr F i) a = y | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
i : I
x : IContainer.M (C F) i
y : M F i
β’ r i (Quot.mk (congr F i) x) y β Quot.mk (congr F i) x = y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.bisim_lemma | [131, 1] | [183, 13] | apply Quot.inductionOn (motive := _) y | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
i : I
x : IContainer.M (C F) i
y : M F i
β’ r i (Quot.mk (congr F i) x) y β Quot.mk (congr F i) x = y | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
i : I
x : IContainer.M (C F) i
y : M F i
β’ β (a : IContainer.M (C F) i),
r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) a) β Quot.mk (congr F i) x = Quot.mk (congr F i) a |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.bisim_lemma | [131, 1] | [183, 13] | clear y | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
i : I
x : IContainer.M (C F) i
y : M F i
β’ β (a : IContainer.M (C F) i),
r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) a) β Quot.mk (congr F i) x = Quot.mk (congr F i) a | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
i : I
x : IContainer.M (C F) i
β’ β (a : IContainer.M (C F) i),
r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) a) β Quot.mk (congr F i) x = Quot.mk (congr F i) a |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.bisim_lemma | [131, 1] | [183, 13] | intro y hβ | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
i : I
x : IContainer.M (C F) i
β’ β (a : IContainer.M (C F) i),
r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) a) β Quot.mk (congr F i) x = Quot.mk (congr F i) a | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
i : I
x y : IContainer.M (C F) i
hβ : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)
β’ Quot.mk (congr F i) x = Quot.mk (congr F i) y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.bisim_lemma | [131, 1] | [183, 13] | apply Quot.sound | I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
i : I
x y : IContainer.M (C F) i
hβ : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)
β’ Quot.mk (congr F i) x = Quot.mk (congr F i) y | case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
i : I
x y : IContainer.M (C F) i
hβ : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)
β’ congr F i x y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/QPF/MIdx.lean | IQPF.M.bisim_lemma | [131, 1] | [183, 13] | let r' i x y := r i (Quot.mk _ x) (Quot.mk _ y) | case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
i : I
x y : IContainer.M (C F) i
hβ : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)
β’ congr F i x y | case a
I : Type uβ
F : (I β Type uβ) β I β Type uβ
inst : IQPF F
r : (i : I) β M F i β M F i β Prop
hβ : β (i : I) (x : M F i), r i x x
hβ :
β (i : I) (x y : M F i),
r i x y β IFunctor.imap (fun i => Quot.mk (r i)) (destruct x) = IFunctor.imap (fun i => Quot.mk (r i)) (destruct y)
i : I
x y : IContainer.M (C F) i
hβ : r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)
r' : (i : I) β IContainer.M (C F) i β IContainer.M (C F) i β Prop :=
fun i x y => r i (Quot.mk (congr F i) x) (Quot.mk (congr F i) y)
β’ congr F i x y |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.