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/BrownCS1951x/fpv2023.git | 9aaf6b5c454aa9a70fc4e6807adf3123b001ea66 | LoVe/Labs/Lab4Solution.lean | LoVe.Vec.meld_append | [167, 1] | [180, 73] | rw [ih] | Ξ± Ξ² Ξ³ : Type
m n : β
f : Ξ± β Ξ² β Ξ³
v : Ξ±
nβ : β
vs : Vec Ξ± nβ
w : Ξ²
ws : Vec Ξ² nβ
xs : Vec Ξ± m
ys : Vec Ξ² m
ih : meld f (append vs xs) (append ws ys) = append (meld f vs ws) (meld f xs ys)
β’ cons (f v w) (meld f (append vs xs) (append ws ys)) = cons (f v w) (append (meld f vs ws) (meld f xs ys)) | no goals |
https://github.com/BrownCS1951x/fpv2023.git | 9aaf6b5c454aa9a70fc4e6807adf3123b001ea66 | LoVe/Labs/Lab4Solution.lean | LoVe.drop_nil | [300, 9] | [303, 20] | rfl | Ξ± : Type
β’ drop 0 [] = [] | no goals |
https://github.com/BrownCS1951x/fpv2023.git | 9aaf6b5c454aa9a70fc4e6807adf3123b001ea66 | LoVe/Labs/Lab4Solution.lean | LoVe.drop_nil | [300, 9] | [303, 20] | rfl | Ξ± : Type
nβ : β
β’ drop (nβ + 1) [] = [] | no goals |
https://github.com/BrownCS1951x/fpv2023.git | 9aaf6b5c454aa9a70fc4e6807adf3123b001ea66 | LoVe/Labs/Lab4Solution.lean | LoVe.take_nil | [305, 9] | [308, 20] | rfl | Ξ± : Type
β’ take 0 [] = [] | no goals |
https://github.com/BrownCS1951x/fpv2023.git | 9aaf6b5c454aa9a70fc4e6807adf3123b001ea66 | LoVe/Labs/Lab4Solution.lean | LoVe.take_nil | [305, 9] | [308, 20] | rfl | Ξ± : Type
nβ : β
β’ take (nβ + 1) [] = [] | no goals |
https://github.com/BrownCS1951x/fpv2023.git | 9aaf6b5c454aa9a70fc4e6807adf3123b001ea66 | LoVe/Labs/Lab4Solution.lean | LoVe.drop_drop | [317, 1] | [322, 50] | rfl | Ξ± : Type
n : β
xs : List Ξ±
β’ drop n (drop 0 xs) = drop (n + 0) xs | no goals |
https://github.com/BrownCS1951x/fpv2023.git | 9aaf6b5c454aa9a70fc4e6807adf3123b001ea66 | LoVe/Labs/Lab4Solution.lean | LoVe.drop_drop | [317, 1] | [322, 50] | simp [drop] | Ξ± : Type
nβ xβ : β
β’ drop xβ (drop (nβ + 1) []) = drop (xβ + (nβ + 1)) [] | no goals |
https://github.com/BrownCS1951x/fpv2023.git | 9aaf6b5c454aa9a70fc4e6807adf3123b001ea66 | LoVe/Labs/Lab4Solution.lean | LoVe.drop_drop | [317, 1] | [322, 50] | simp [drop, drop_drop m n xs, β add_assoc] | Ξ± : Type
m n : β
headβ : Ξ±
xs : List Ξ±
β’ drop n (drop (m + 1) (headβ :: xs)) = drop (n + (m + 1)) (headβ :: xs) | no goals |
https://github.com/BrownCS1951x/fpv2023.git | 9aaf6b5c454aa9a70fc4e6807adf3123b001ea66 | LoVe/Labs/Lab4Solution.lean | LoVe.take_take | [324, 1] | [328, 53] | rfl | Ξ± : Type
xβ : List Ξ±
β’ take 0 (take 0 xβ) = take 0 xβ | no goals |
https://github.com/BrownCS1951x/fpv2023.git | 9aaf6b5c454aa9a70fc4e6807adf3123b001ea66 | LoVe/Labs/Lab4Solution.lean | LoVe.take_take | [324, 1] | [328, 53] | rfl | Ξ± : Type
nβ : β
β’ take (nβ + 1) (take (nβ + 1) []) = take (nβ + 1) [] | no goals |
https://github.com/BrownCS1951x/fpv2023.git | 9aaf6b5c454aa9a70fc4e6807adf3123b001ea66 | LoVe/Labs/Lab4Solution.lean | LoVe.take_take | [324, 1] | [328, 53] | simp [take, take_take m xs] | Ξ± : Type
m : β
x : Ξ±
xs : List Ξ±
β’ take (m + 1) (take (m + 1) (x :: xs)) = take (m + 1) (x :: xs) | no goals |
https://github.com/BrownCS1951x/fpv2023.git | 9aaf6b5c454aa9a70fc4e6807adf3123b001ea66 | LoVe/Labs/Lab4Solution.lean | LoVe.take_drop | [330, 1] | [334, 56] | rfl | Ξ± : Type
xβ : List Ξ±
β’ take 0 xβ ++ drop 0 xβ = xβ | no goals |
https://github.com/BrownCS1951x/fpv2023.git | 9aaf6b5c454aa9a70fc4e6807adf3123b001ea66 | LoVe/Labs/Lab4Solution.lean | LoVe.take_drop | [330, 1] | [334, 56] | rfl | Ξ± : Type
nβ : β
β’ take (nβ + 1) [] ++ drop (nβ + 1) [] = [] | no goals |
https://github.com/BrownCS1951x/fpv2023.git | 9aaf6b5c454aa9a70fc4e6807adf3123b001ea66 | LoVe/Labs/Lab4Solution.lean | LoVe.take_drop | [330, 1] | [334, 56] | simp [take, drop, take_drop m] | Ξ± : Type
m : β
x : Ξ±
xs : List Ξ±
β’ take (m + 1) (x :: xs) ++ drop (m + 1) (x :: xs) = x :: xs | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | let R (x y: M C) := x = construct (destruct y) | C : Container
x : M C
β’ construct (destruct x) = x | C : Container
x : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
β’ construct (destruct x) = x |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | apply bisim R | C : Container
x : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
β’ construct (destruct x) = x | case hβ
C : Container
x : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
β’ β (x y : M C),
R x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (i : B C node), R (kβ i) (kβ i)
case a
C : Container
x : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
β’ R (construct (destruct x)) x |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | . intro x y hβ
have hβ := congrArg destruct hβ
cases hβ:destruct y
case mk node kβ =>
rw [hβ] at hβ
simp only [construct, destruct_corec, Map] at hβ
simp only [construct.automaton, Map] at hβ
exists node
exists construct β destruct β kβ
exists kβ
constructor
. exact hβ
. constructor
. rfl
. intro i
rfl | case hβ
C : Container
x : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
β’ β (x y : M C),
R x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (i : B C node), R (kβ i) (kβ i)
case a
C : Container
x : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
β’ R (construct (destruct x)) x | case a
C : Container
x : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
β’ R (construct (destruct x)) x |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | . rfl | case a
C : Container
x : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
β’ R (construct (destruct x)) x | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | intro x y hβ | case hβ
C : Container
x : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
β’ β (x y : M C),
R x y β
β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (i : B C node), R (kβ i) (kβ i) | case hβ
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hβ : R x y
β’ β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (i : B C node), R (kβ i) (kβ i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | have hβ := congrArg destruct hβ | case hβ
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hβ : R x y
β’ β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (i : B C node), R (kβ i) (kβ i) | case hβ
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
hβ : destruct x = destruct (construct (destruct y))
β’ β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (i : B C node), R (kβ i) (kβ i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | cases hβ:destruct y | case hβ
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
hβ : destruct x = destruct (construct (destruct y))
β’ β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
destruct y = { fst := node, snd := kβ } β§ β (i : B C node), R (kβ i) (kβ i) | case hβ.mk
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
hβ : destruct x = destruct (construct (destruct y))
fstβ : C.A
sndβ : B C fstβ β M C
hβ : destruct y = { fst := fstβ, snd := sndβ }
β’ β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
{ fst := fstβ, snd := sndβ } = { fst := node, snd := kβ } β§ β (i : B C node), R (kβ i) (kβ i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | case mk node kβ =>
rw [hβ] at hβ
simp only [construct, destruct_corec, Map] at hβ
simp only [construct.automaton, Map] at hβ
exists node
exists construct β destruct β kβ
exists kβ
constructor
. exact hβ
. constructor
. rfl
. intro i
rfl | C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
hβ : destruct x = destruct (construct (destruct y))
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
β’ β node_1 kβ kβ_1,
destruct x = { fst := node_1, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node_1, snd := kβ_1 } β§ β (i : B C node_1), R (kβ i) (kβ_1 i) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | rw [hβ] at hβ | C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
hβ : destruct x = destruct (construct (destruct y))
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
β’ β node_1 kβ kβ_1,
destruct x = { fst := node_1, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node_1, snd := kβ_1 } β§ β (i : B C node_1), R (kβ i) (kβ_1 i) | C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct x = destruct (construct { fst := node, snd := kβ })
hβ : destruct y = { fst := node, snd := kβ }
β’ β node_1 kβ kβ_1,
destruct x = { fst := node_1, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node_1, snd := kβ_1 } β§ β (i : B C node_1), R (kβ i) (kβ_1 i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | simp only [construct, destruct_corec, Map] at hβ | C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct x = destruct (construct { fst := node, snd := kβ })
hβ : destruct y = { fst := node, snd := kβ }
β’ β node_1 kβ kβ_1,
destruct x = { fst := node_1, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node_1, snd := kβ_1 } β§ β (i : B C node_1), R (kβ i) (kβ_1 i) | C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := (construct.automaton { fst := node, snd := kβ }).fst,
snd := corec construct.automaton β (construct.automaton { fst := node, snd := kβ }).snd }
β’ β node_1 kβ kβ_1,
destruct x = { fst := node_1, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node_1, snd := kβ_1 } β§ β (i : B C node_1), R (kβ i) (kβ_1 i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | simp only [construct.automaton, Map] at hβ | C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := (construct.automaton { fst := node, snd := kβ }).fst,
snd := corec construct.automaton β (construct.automaton { fst := node, snd := kβ }).snd }
β’ β node_1 kβ kβ_1,
destruct x = { fst := node_1, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node_1, snd := kβ_1 } β§ β (i : B C node_1), R (kβ i) (kβ_1 i) | C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ β node_1 kβ kβ_1,
destruct x = { fst := node_1, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node_1, snd := kβ_1 } β§ β (i : B C node_1), R (kβ i) (kβ_1 i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | exists node | C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ β node_1 kβ kβ_1,
destruct x = { fst := node_1, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node_1, snd := kβ_1 } β§ β (i : B C node_1), R (kβ i) (kβ_1 i) | C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ β kβ kβ_1,
destruct x = { fst := node, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node, snd := kβ_1 } β§ β (i : B C node), R (kβ i) (kβ_1 i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | exists construct β destruct β kβ | C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ β kβ kβ_1,
destruct x = { fst := node, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node, snd := kβ_1 } β§ β (i : B C node), R (kβ i) (kβ_1 i) | C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ β kβ_1,
destruct x = { fst := node, snd := construct β destruct β kβ } β§
{ fst := node, snd := kβ } = { fst := node, snd := kβ_1 } β§
β (i : B C node), R ((construct β destruct β kβ) i) (kβ_1 i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | exists kβ | C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ β kβ_1,
destruct x = { fst := node, snd := construct β destruct β kβ } β§
{ fst := node, snd := kβ } = { fst := node, snd := kβ_1 } β§
β (i : B C node), R ((construct β destruct β kβ) i) (kβ_1 i) | C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ destruct x = { fst := node, snd := construct β destruct β kβ } β§
{ fst := node, snd := kβ } = { fst := node, snd := kβ } β§ β (i : B C node), R ((construct β destruct β kβ) i) (kβ i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | constructor | C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ destruct x = { fst := node, snd := construct β destruct β kβ } β§
{ fst := node, snd := kβ } = { fst := node, snd := kβ } β§ β (i : B C node), R ((construct β destruct β kβ) i) (kβ i) | case left
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ destruct x = { fst := node, snd := construct β destruct β kβ }
case right
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ { fst := node, snd := kβ } = { fst := node, snd := kβ } β§ β (i : B C node), R ((construct β destruct β kβ) i) (kβ i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | . exact hβ | case left
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ destruct x = { fst := node, snd := construct β destruct β kβ }
case right
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ { fst := node, snd := kβ } = { fst := node, snd := kβ } β§ β (i : B C node), R ((construct β destruct β kβ) i) (kβ i) | case right
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ { fst := node, snd := kβ } = { fst := node, snd := kβ } β§ β (i : B C node), R ((construct β destruct β kβ) i) (kβ i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | . constructor
. rfl
. intro i
rfl | case right
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ { fst := node, snd := kβ } = { fst := node, snd := kβ } β§ β (i : B C node), R ((construct β destruct β kβ) i) (kβ i) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | exact hβ | case left
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ destruct x = { fst := node, snd := construct β destruct β kβ } | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | constructor | case right
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ { fst := node, snd := kβ } = { fst := node, snd := kβ } β§ β (i : B C node), R ((construct β destruct β kβ) i) (kβ i) | case right.left
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ { fst := node, snd := kβ } = { fst := node, snd := kβ }
case right.right
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ β (i : B C node), R ((construct β destruct β kβ) i) (kβ i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | . rfl | case right.left
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ { fst := node, snd := kβ } = { fst := node, snd := kβ }
case right.right
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ β (i : B C node), R ((construct β destruct β kβ) i) (kβ i) | case right.right
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ β (i : B C node), R ((construct β destruct β kβ) i) (kβ i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | . intro i
rfl | case right.right
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ β (i : B C node), R ((construct β destruct β kβ) i) (kβ i) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | rfl | case right.left
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ { fst := node, snd := kβ } = { fst := node, snd := kβ } | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | intro i | case right.right
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
β’ β (i : B C node), R ((construct β destruct β kβ) i) (kβ i) | case right.right
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
i : B C node
β’ R ((construct β destruct β kβ) i) (kβ i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | rfl | case right.right
C : Container
xβ : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
x y : M C
hββ : R x y
node : C.A
kβ : B C node β M C
hβ : destruct y = { fst := node, snd := kβ }
hβ : destruct x = { fst := node, snd := (corec fun x => { fst := x.fst, snd := destruct β x.snd }) β destruct β kβ }
i : B C node
β’ R ((construct β destruct β kβ) i) (kβ i) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | Container.M.construct_destruct | [16, 1] | [36, 8] | rfl | case a
C : Container
x : M C
R : M C β M C β Prop := fun x y => x = construct (destruct y)
β’ R (construct (destruct x)) x | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | let R i (x y: M C i) := x = construct (destruct y) | I : Type uβ
C : IContainer I
i : I
x : M C i
β’ construct (destruct x) = x | I : Type uβ
C : IContainer I
i : I
x : M C i
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
β’ construct (destruct x) = x |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | apply bisim R | I : Type uβ
C : IContainer I
i : I
x : M C i
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
β’ construct (destruct x) = x | case hβ
I : Type uβ
C : IContainer I
i : I
x : M C i
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
β’ β (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)
case a
I : Type uβ
C : IContainer I
i : I
x : M C i
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
β’ R i (construct (destruct x)) x |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | . intro i x y hβ
have hβ := congrArg destruct hβ
cases hβ:destruct y
case mk node kβ =>
rw [hβ] at hβ
simp only [construct, destruct_corec, Map] at hβ
simp only [construct.automaton, Map] at hβ
exists node
exists Ξ» (x:B C i node) => construct <| destruct <| kβ x
exists kβ
constructor
. exact hβ
. constructor
. rfl
. intro i
rfl | case hβ
I : Type uβ
C : IContainer I
i : I
x : M C i
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
β’ β (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)
case a
I : Type uβ
C : IContainer I
i : I
x : M C i
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
β’ R i (construct (destruct x)) x | case a
I : Type uβ
C : IContainer I
i : I
x : M C i
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
β’ R i (construct (destruct x)) x |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | . rfl | case a
I : Type uβ
C : IContainer I
i : I
x : M C i
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
β’ R i (construct (destruct x)) x | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | intro i x y hβ | case hβ
I : Type uβ
C : IContainer I
i : I
x : M C i
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
β’ β (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) | case hβ
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hβ : 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) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | have hβ := congrArg destruct hβ | case hβ
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hβ : 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) | case hβ
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
hβ : destruct x = destruct (construct (destruct 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) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | cases hβ:destruct y | case hβ
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
hβ : destruct x = destruct (construct (destruct 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) | case hβ.mk
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
hβ : destruct x = destruct (construct (destruct y))
fstβ : A C i
sndβ : (y : B C i fstβ) β M C (N C i fstβ y)
hβ : destruct y = { fst := fstβ, snd := sndβ }
β’ β node kβ kβ,
destruct x = { fst := node, snd := kβ } β§
{ fst := fstβ, snd := sndβ } = { fst := node, snd := kβ } β§ β (z : B C i node), R (N C i node z) (kβ z) (kβ z) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | case mk node kβ =>
rw [hβ] at hβ
simp only [construct, destruct_corec, Map] at hβ
simp only [construct.automaton, Map] at hβ
exists node
exists Ξ» (x:B C i node) => construct <| destruct <| kβ x
exists kβ
constructor
. exact hβ
. constructor
. rfl
. intro i
rfl | I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
hβ : destruct x = destruct (construct (destruct y))
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
β’ β node_1 kβ kβ_1,
destruct x = { fst := node_1, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node_1, snd := kβ_1 } β§
β (z : B C i node_1), R (N C i node_1 z) (kβ z) (kβ_1 z) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | rw [hβ] at hβ | I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
hβ : destruct x = destruct (construct (destruct y))
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
β’ β node_1 kβ kβ_1,
destruct x = { fst := node_1, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node_1, snd := kβ_1 } β§
β (z : B C i node_1), R (N C i node_1 z) (kβ z) (kβ_1 z) | I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct x = destruct (construct { fst := node, snd := kβ })
hβ : destruct y = { fst := node, snd := kβ }
β’ β node_1 kβ kβ_1,
destruct x = { fst := node_1, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node_1, snd := kβ_1 } β§
β (z : B C i node_1), R (N C i node_1 z) (kβ z) (kβ_1 z) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | simp only [construct, destruct_corec, Map] at hβ | I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct x = destruct (construct { fst := node, snd := kβ })
hβ : destruct y = { fst := node, snd := kβ }
β’ β node_1 kβ kβ_1,
destruct x = { fst := node_1, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node_1, snd := kβ_1 } β§
β (z : B C i node_1), R (N C i node_1 z) (kβ z) (kβ_1 z) | I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
match construct.automaton i { fst := node, snd := kβ } with
| { fst := x, snd := k } => { fst := x, snd := fun y => corec construct.automaton (k y) }
β’ β node_1 kβ kβ_1,
destruct x = { fst := node_1, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node_1, snd := kβ_1 } β§
β (z : B C i node_1), R (N C i node_1 z) (kβ z) (kβ_1 z) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | simp only [construct.automaton, Map] at hβ | I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
match construct.automaton i { fst := node, snd := kβ } with
| { fst := x, snd := k } => { fst := x, snd := fun y => corec construct.automaton (k y) }
β’ β node_1 kβ kβ_1,
destruct x = { fst := node_1, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node_1, snd := kβ_1 } β§
β (z : B C i node_1), R (N C i node_1 z) (kβ z) (kβ_1 z) | I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ β node_1 kβ kβ_1,
destruct x = { fst := node_1, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node_1, snd := kβ_1 } β§
β (z : B C i node_1), R (N C i node_1 z) (kβ z) (kβ_1 z) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | exists node | I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ β node_1 kβ kβ_1,
destruct x = { fst := node_1, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node_1, snd := kβ_1 } β§
β (z : B C i node_1), R (N C i node_1 z) (kβ z) (kβ_1 z) | I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ β kβ kβ_1,
destruct x = { fst := node, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node, snd := kβ_1 } β§ β (z : B C i node), R (N C i node z) (kβ z) (kβ_1 z) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | exists Ξ» (x:B C i node) => construct <| destruct <| kβ x | I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ β kβ kβ_1,
destruct x = { fst := node, snd := kβ } β§
{ fst := node, snd := kβ } = { fst := node, snd := kβ_1 } β§ β (z : B C i node), R (N C i node z) (kβ z) (kβ_1 z) | I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ β kβ_1,
destruct x = { fst := node, snd := fun x => construct (destruct (kβ x)) } β§
{ fst := node, snd := kβ } = { fst := node, snd := kβ_1 } β§
β (z : B C i node), R (N C i node z) ((fun x => construct (destruct (kβ x))) z) (kβ_1 z) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | exists kβ | I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ β kβ_1,
destruct x = { fst := node, snd := fun x => construct (destruct (kβ x)) } β§
{ fst := node, snd := kβ } = { fst := node, snd := kβ_1 } β§
β (z : B C i node), R (N C i node z) ((fun x => construct (destruct (kβ x))) z) (kβ_1 z) | I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ destruct x = { fst := node, snd := fun x => construct (destruct (kβ x)) } β§
{ fst := node, snd := kβ } = { fst := node, snd := kβ } β§
β (z : B C i node), R (N C i node z) ((fun x => construct (destruct (kβ x))) z) (kβ z) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | constructor | I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ destruct x = { fst := node, snd := fun x => construct (destruct (kβ x)) } β§
{ fst := node, snd := kβ } = { fst := node, snd := kβ } β§
β (z : B C i node), R (N C i node z) ((fun x => construct (destruct (kβ x))) z) (kβ z) | case left
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ destruct x = { fst := node, snd := fun x => construct (destruct (kβ x)) }
case right
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ { fst := node, snd := kβ } = { fst := node, snd := kβ } β§
β (z : B C i node), R (N C i node z) ((fun x => construct (destruct (kβ x))) z) (kβ z) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | . exact hβ | case left
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ destruct x = { fst := node, snd := fun x => construct (destruct (kβ x)) }
case right
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ { fst := node, snd := kβ } = { fst := node, snd := kβ } β§
β (z : B C i node), R (N C i node z) ((fun x => construct (destruct (kβ x))) z) (kβ z) | case right
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ { fst := node, snd := kβ } = { fst := node, snd := kβ } β§
β (z : B C i node), R (N C i node z) ((fun x => construct (destruct (kβ x))) z) (kβ z) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | . constructor
. rfl
. intro i
rfl | case right
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ { fst := node, snd := kβ } = { fst := node, snd := kβ } β§
β (z : B C i node), R (N C i node z) ((fun x => construct (destruct (kβ x))) z) (kβ z) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | exact hβ | case left
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ destruct x = { fst := node, snd := fun x => construct (destruct (kβ x)) } | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | constructor | case right
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ { fst := node, snd := kβ } = { fst := node, snd := kβ } β§
β (z : B C i node), R (N C i node z) ((fun x => construct (destruct (kβ x))) z) (kβ z) | case right.left
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ { fst := node, snd := kβ } = { fst := node, snd := kβ }
case right.right
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ β (z : B C i node), R (N C i node z) ((fun x => construct (destruct (kβ x))) z) (kβ z) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | . rfl | case right.left
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ { fst := node, snd := kβ } = { fst := node, snd := kβ }
case right.right
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ β (z : B C i node), R (N C i node z) ((fun x => construct (destruct (kβ x))) z) (kβ z) | case right.right
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ β (z : B C i node), R (N C i node z) ((fun x => construct (destruct (kβ x))) z) (kβ z) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | . intro i
rfl | case right.right
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ β (z : B C i node), R (N C i node z) ((fun x => construct (destruct (kβ x))) z) (kβ z) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | rfl | case right.left
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ { fst := node, snd := kβ } = { fst := node, snd := kβ } | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | intro i | case right.right
I : Type uβ
C : IContainer I
iβ : I
xβ : M C iβ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
i : I
x y : M C i
hββ : R i x y
node : A C i
kβ : (y : B C i node) β M C (N C i node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
β’ β (z : B C i node), R (N C i node z) ((fun x => construct (destruct (kβ x))) z) (kβ z) | case right.right
I : Type uβ
C : IContainer I
iβΒΉ : I
xβ : M C iβΒΉ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
iβ : I
x y : M C iβ
hββ : R iβ x y
node : A C iβ
kβ : (y : B C iβ node) β M C (N C iβ node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
i : B C iβ node
β’ R (N C iβ node i) ((fun x => construct (destruct (kβ x))) i) (kβ i) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | rfl | case right.right
I : Type uβ
C : IContainer I
iβΒΉ : I
xβ : M C iβΒΉ
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
iβ : I
x y : M C iβ
hββ : R iβ x y
node : A C iβ
kβ : (y : B C iβ node) β M C (N C iβ node y)
hβ : destruct y = { fst := node, snd := kβ }
hβ :
destruct x =
{ fst := node,
snd := fun y =>
corec
(fun i x =>
match x with
| { fst := x, snd := k } => { fst := x, snd := fun y => destruct (k y) })
(destruct (kβ y)) }
i : B C iβ node
β’ R (N C iβ node i) ((fun x => construct (destruct (kβ x))) i) (kβ i) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | IContainer.M.construct_destruct | [84, 1] | [104, 8] | rfl | case a
I : Type uβ
C : IContainer I
i : I
x : M C i
R : (i : I) β M C i β M C i β Prop := fun i x y => x = construct (destruct y)
β’ R i (construct (destruct x)) x | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | let R (x y: M F) := x = construct (destruct y) | F : Type uβ β Type uβ
inst : QPF F
x : M F
β’ construct (destruct x) = x | F : Type uβ β Type uβ
inst : QPF F
x : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
β’ construct (destruct x) = x |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | apply bisim R | F : Type uβ β Type uβ
inst : QPF F
x : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
β’ construct (destruct x) = x | case hβ
F : Type uβ β Type uβ
inst : QPF F
x : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
β’ β (x y : M F), R x y β liftr F R (destruct x) (destruct y)
case a
F : Type uβ β Type uβ
inst : QPF F
x : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
β’ R (construct (destruct x)) x |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | . intro x y hβ
have hβ := congrArg destruct hβ
simp [liftr]
simp only [construct, destruct_corec, construct.automaton] at hβ
exists Functor.map (Ξ» a => β¨β¨construct <| destruct a, aβ©, by simpβ©) (destruct y)
rw [hβ]
constructor
. simp only [βQPF.map_comp]
rfl
. rw [βQPF.M.map_comp]
have : inst.map id (destruct y) = destruct y := by rw [QPF.map_id]
apply Eq.trans _ this
apply congrFun
funext _
rfl | case hβ
F : Type uβ β Type uβ
inst : QPF F
x : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
β’ β (x y : M F), R x y β liftr F R (destruct x) (destruct y)
case a
F : Type uβ β Type uβ
inst : QPF F
x : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
β’ R (construct (destruct x)) x | case a
F : Type uβ β Type uβ
inst : QPF F
x : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
β’ R (construct (destruct x)) x |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | . rfl | case a
F : Type uβ β Type uβ
inst : QPF F
x : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
β’ R (construct (destruct x)) x | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | intro x y hβ | case hβ
F : Type uβ β Type uβ
inst : QPF F
x : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
β’ β (x y : M F), R x y β liftr F R (destruct x) (destruct y) | case hβ
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hβ : R x y
β’ liftr F R (destruct x) (destruct y) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | have hβ := congrArg destruct hβ | case hβ
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hβ : R x y
β’ liftr F R (destruct x) (destruct y) | case hβ
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = destruct (construct (destruct y))
β’ liftr F R (destruct x) (destruct y) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | simp [liftr] | case hβ
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = destruct (construct (destruct y))
β’ liftr F R (destruct x) (destruct y) | case hβ
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = destruct (construct (destruct y))
β’ β z, (fun x => (βx).fst) <$> z = destruct x β§ (fun x => (βx).snd) <$> z = destruct y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | simp only [construct, destruct_corec, construct.automaton] at hβ | case hβ
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = destruct (construct (destruct y))
β’ β z, (fun x => (βx).fst) <$> z = destruct x β§ (fun x => (βx).snd) <$> z = destruct y | case hβ
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ β z, (fun x => (βx).fst) <$> z = destruct x β§ (fun x => (βx).snd) <$> z = destruct y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | exists Functor.map (Ξ» a => β¨β¨construct <| destruct a, aβ©, by simpβ©) (destruct y) | case hβ
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ β z, (fun x => (βx).fst) <$> z = destruct x β§ (fun x => (βx).snd) <$> z = destruct y | case hβ
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ (fun x => (βx).fst) <$>
(fun a =>
{ val := (construct (destruct a), a),
property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
destruct x β§
(fun x => (βx).snd) <$>
(fun a =>
{ val := (construct (destruct a), a),
property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
destruct y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | rw [hβ] | case hβ
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ (fun x => (βx).fst) <$>
(fun a =>
{ val := (construct (destruct a), a),
property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
destruct x β§
(fun x => (βx).snd) <$>
(fun a =>
{ val := (construct (destruct a), a),
property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
destruct y | case hβ
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ (fun x => (βx).fst) <$>
(fun a =>
{ val := (construct (destruct a), a),
property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
(fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y β§
(fun x => (βx).snd) <$>
(fun a =>
{ val := (construct (destruct a), a),
property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
destruct y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | constructor | case hβ
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ (fun x => (βx).fst) <$>
(fun a =>
{ val := (construct (destruct a), a),
property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
(fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y β§
(fun x => (βx).snd) <$>
(fun a =>
{ val := (construct (destruct a), a),
property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
destruct y | case hβ.left
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ (fun x => (βx).fst) <$>
(fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
(fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
case hβ.right
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ (fun x => (βx).snd) <$>
(fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
destruct y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | . simp only [βQPF.map_comp]
rfl | case hβ.left
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ (fun x => (βx).fst) <$>
(fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
(fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
case hβ.right
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ (fun x => (βx).snd) <$>
(fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
destruct y | case hβ.right
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ (fun x => (βx).snd) <$>
(fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
destruct y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | . rw [βQPF.M.map_comp]
have : inst.map id (destruct y) = destruct y := by rw [QPF.map_id]
apply Eq.trans _ this
apply congrFun
funext _
rfl | case hβ.right
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ (fun x => (βx).snd) <$>
(fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
destruct y | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | simp | F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
a : M F
β’ (construct (destruct a), a).fst = construct (destruct (construct (destruct a), a).snd) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | simp only [βQPF.map_comp] | case hβ.left
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ (fun x => (βx).fst) <$>
(fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
(fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y | case hβ.left
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ ((fun x => (βx).fst) β fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
((fun x => corec (Functor.map destruct) x) β destruct) <$> destruct y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | rfl | case hβ.left
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ ((fun x => (βx).fst) β fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
((fun x => corec (Functor.map destruct) x) β destruct) <$> destruct y | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | rw [βQPF.M.map_comp] | case hβ.right
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ (fun x => (βx).snd) <$>
(fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
destruct y | case hβ.right
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ ((fun x => (βx).snd) β fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
destruct y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | have : inst.map id (destruct y) = destruct y := by rw [QPF.map_id] | case hβ.right
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ ((fun x => (βx).snd) β fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
destruct y | case hβ.right
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
this : id <$> destruct y = destruct y
β’ ((fun x => (βx).snd) β fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
destruct y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | apply Eq.trans _ this | case hβ.right
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
this : id <$> destruct y = destruct y
β’ ((fun x => (βx).snd) β fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
destruct y | F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
this : id <$> destruct y = destruct y
β’ ((fun x => (βx).snd) β fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
id <$> destruct y |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | apply congrFun | F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
this : id <$> destruct y = destruct y
β’ ((fun x => (βx).snd) β fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
destruct y =
id <$> destruct y | case h
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
this : id <$> destruct y = destruct y
β’ Functor.map
((fun x => (βx).snd) β fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) =
Functor.map id |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | funext _ | case h
F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
this : id <$> destruct y = destruct y
β’ Functor.map
((fun x => (βx).snd) β fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) =
Functor.map id | case h.h
F : Type uβ β Type uβ
inst : QPF F
xβΒΉ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
this : id <$> destruct y = destruct y
xβ : F (M F)
β’ ((fun x => (βx).snd) β fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
xβ =
id <$> xβ |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | rfl | case h.h
F : Type uβ β Type uβ
inst : QPF F
xβΒΉ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
this : id <$> destruct y = destruct y
xβ : F (M F)
β’ ((fun x => (βx).snd) β fun a =>
{ val := (construct (destruct a), a), property := (_ : construct (destruct a) = construct (destruct a)) }) <$>
xβ =
id <$> xβ | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | rw [QPF.map_id] | F : Type uβ β Type uβ
inst : QPF F
xβ : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
x y : M F
hββ : R x y
hβ : destruct x = (fun x => corec (Functor.map destruct) x) <$> destruct <$> destruct y
β’ id <$> destruct y = destruct y | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Utils.lean | QPF.M.construct_destruct | [152, 1] | [172, 8] | rfl | case a
F : Type uβ β Type uβ
inst : QPF F
x : M F
R : M F β M F β Prop := fun x y => x = construct (destruct y)
β’ R (construct (destruct x)) x | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/M.lean | Container.M.destruct_corec | [107, 1] | [111, 6] | simp only [corec, destruct] | C : Container
Ξ± : Type uβ
f : Ξ± β Obj C Ξ±
xβ : Ξ±
β’ destruct (corec f xβ) = Map (corec f) (f xβ) | C : Container
Ξ± : Type uβ
f : Ξ± β Obj C Ξ±
xβ : Ξ±
β’ {
fst :=
node
{ approx := Approx.corec f xβ,
agrees := (_ : β (n : Nat), Agree (Approx.corec f xβ n) (Approx.corec f xβ (Nat.succ n))) },
snd :=
children
{ approx := Approx.corec f xβ,
agrees := (_ : β (n : Nat), Agree (Approx.corec f xβ n) (Approx.corec f xβ (Nat.succ n))) } } =
Map
(fun xβ =>
{ approx := Approx.corec f xβ,
agrees := (_ : β (n : Nat), Agree (Approx.corec f xβ n) (Approx.corec f xβ (Nat.succ n))) })
(f xβ) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/M.lean | Container.M.destruct_corec | [107, 1] | [111, 6] | rfl | C : Container
Ξ± : Type uβ
f : Ξ± β Obj C Ξ±
xβ : Ξ±
β’ {
fst :=
node
{ approx := Approx.corec f xβ,
agrees := (_ : β (n : Nat), Agree (Approx.corec f xβ n) (Approx.corec f xβ (Nat.succ n))) },
snd :=
children
{ approx := Approx.corec f xβ,
agrees := (_ : β (n : Nat), Agree (Approx.corec f xβ n) (Approx.corec f xβ (Nat.succ n))) } } =
Map
(fun xβ =>
{ approx := Approx.corec f xβ,
agrees := (_ : β (n : Nat), Agree (Approx.corec f xβ n) (Approx.corec f xβ (Nat.succ n))) })
(f xβ) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/M.lean | Container.Eq_from_Heq | [115, 1] | [119, 17] | cases h | C : Container
Ξ± Ξ² : Sort uβ
i : Ξ±
j : Ξ²
hβ : Ξ± = Ξ²
h : HEq i j
β’ cast hβ i = j | case refl
C : Container
Ξ± : Sort uβ
i : Ξ±
hβ : Ξ± = Ξ±
β’ cast hβ i = i |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/M.lean | Container.Eq_from_Heq | [115, 1] | [119, 17] | apply eq_of_heq | case refl
C : Container
Ξ± : Sort uβ
i : Ξ±
hβ : Ξ± = Ξ±
β’ cast hβ i = i | case refl.h
C : Container
Ξ± : Sort uβ
i : Ξ±
hβ : Ξ± = Ξ±
β’ HEq (cast hβ i) i |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/M.lean | Container.Eq_from_Heq | [115, 1] | [119, 17] | apply cast_heq | case refl.h
C : Container
Ξ± : Sort uβ
i : Ξ±
hβ : Ξ± = Ξ±
β’ HEq (cast hβ i) i | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/M.lean | Container.M.bisim.lemma0 | [121, 1] | [131, 52] | intro x n i j heq | C : Container
β’ β (x : M C) (n : Nat) (i : B C (Approx.node (approx x (Nat.succ n)))) (j : B C (destruct x).fst),
HEq i j β Approx.children (approx x (Nat.succ n)) i = approx (PSigma.snd (destruct x) j) n | C : Container
x : M C
n : Nat
i : B C (Approx.node (approx x (Nat.succ n)))
j : B C (destruct x).fst
heq : HEq i j
β’ Approx.children (approx x (Nat.succ n)) i = approx (PSigma.snd (destruct x) j) n |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/M.lean | Container.M.bisim.lemma0 | [121, 1] | [131, 52] | have : i = cast (by rw [node_thm]; simp [destruct]) j := by
have : C.B x.destruct.fst = C.B (x.approx (.succ n)).node := by rw [node_thm]; simp [destruct]
rw [Eq_from_Heq j i]
apply HEq.symm
assumption | C : Container
x : M C
n : Nat
i : B C (Approx.node (approx x (Nat.succ n)))
j : B C (destruct x).fst
heq : HEq i j
β’ Approx.children (approx x (Nat.succ n)) i = approx (PSigma.snd (destruct x) j) n | C : Container
x : M C
n : Nat
i : B C (Approx.node (approx x (Nat.succ n)))
j : B C (destruct x).fst
heq : HEq i j
this : i = cast (_ : B C (destruct x).fst = B C (Approx.node (approx x (Nat.succ n)))) j
β’ Approx.children (approx x (Nat.succ n)) i = approx (PSigma.snd (destruct x) j) n |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/M.lean | Container.M.bisim.lemma0 | [121, 1] | [131, 52] | simp only [this, children, Approx.node, destruct] | C : Container
x : M C
n : Nat
i : B C (Approx.node (approx x (Nat.succ n)))
j : B C (destruct x).fst
heq : HEq i j
this : i = cast (_ : B C (destruct x).fst = B C (Approx.node (approx x (Nat.succ n)))) j
β’ Approx.children (approx x (Nat.succ n)) i = approx (PSigma.snd (destruct x) j) n | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/M.lean | Container.M.bisim.lemma0 | [121, 1] | [131, 52] | rw [node_thm] | C : Container
x : M C
n : Nat
i : B C (Approx.node (approx x (Nat.succ n)))
j : B C (destruct x).fst
heq : HEq i j
β’ B C (destruct x).fst = B C (Approx.node (approx x (Nat.succ n))) | C : Container
x : M C
n : Nat
i : B C (Approx.node (approx x (Nat.succ n)))
j : B C (destruct x).fst
heq : HEq i j
β’ B C (destruct x).fst = B C (node x) |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/M.lean | Container.M.bisim.lemma0 | [121, 1] | [131, 52] | simp [destruct] | C : Container
x : M C
n : Nat
i : B C (Approx.node (approx x (Nat.succ n)))
j : B C (destruct x).fst
heq : HEq i j
β’ B C (destruct x).fst = B C (node x) | no goals |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/M.lean | Container.M.bisim.lemma0 | [121, 1] | [131, 52] | have : C.B x.destruct.fst = C.B (x.approx (.succ n)).node := by rw [node_thm]; simp [destruct] | C : Container
x : M C
n : Nat
i : B C (Approx.node (approx x (Nat.succ n)))
j : B C (destruct x).fst
heq : HEq i j
β’ i = cast (_ : B C (destruct x).fst = B C (Approx.node (approx x (Nat.succ n)))) j | C : Container
x : M C
n : Nat
i : B C (Approx.node (approx x (Nat.succ n)))
j : B C (destruct x).fst
heq : HEq i j
this : B C (destruct x).fst = B C (Approx.node (approx x (Nat.succ n)))
β’ i = cast (_ : B C (destruct x).fst = B C (Approx.node (approx x (Nat.succ n)))) j |
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/M.lean | Container.M.bisim.lemma0 | [121, 1] | [131, 52] | rw [Eq_from_Heq j i] | C : Container
x : M C
n : Nat
i : B C (Approx.node (approx x (Nat.succ n)))
j : B C (destruct x).fst
heq : HEq i j
this : B C (destruct x).fst = B C (Approx.node (approx x (Nat.succ n)))
β’ i = cast (_ : B C (destruct x).fst = B C (Approx.node (approx x (Nat.succ n)))) j | case h
C : Container
x : M C
n : Nat
i : B C (Approx.node (approx x (Nat.succ n)))
j : B C (destruct x).fst
heq : HEq i j
this : B C (destruct x).fst = B C (Approx.node (approx x (Nat.succ n)))
β’ HEq j i |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.