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 | input stringlengths 73 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 | Please generate a tactic in lean4 to solve the state.
STATE:
α β γ : 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))
TACTIC:
|
https://github.com/BrownCS1951x/fpv2023.git | 9aaf6b5c454aa9a70fc4e6807adf3123b001ea66 | LoVe/Labs/Lab4Solution.lean | LoVe.drop_nil | [300, 9] | [303, 20] | rfl | α : Type
⊢ drop 0 [] = [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
⊢ drop 0 [] = []
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
n✝ : ℕ
⊢ drop (n✝ + 1) [] = []
TACTIC:
|
https://github.com/BrownCS1951x/fpv2023.git | 9aaf6b5c454aa9a70fc4e6807adf3123b001ea66 | LoVe/Labs/Lab4Solution.lean | LoVe.take_nil | [305, 9] | [308, 20] | rfl | α : Type
⊢ take 0 [] = [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
⊢ take 0 [] = []
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
n✝ : ℕ
⊢ take (n✝ + 1) [] = []
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
n : ℕ
xs : List α
⊢ drop n (drop 0 xs) = drop (n + 0) xs
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
n✝ x✝ : ℕ
⊢ drop x✝ (drop (n✝ + 1) []) = drop (x✝ + (n✝ + 1)) []
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
m n : ℕ
head✝ : α
xs : List α
⊢ drop n (drop (m + 1) (head✝ :: xs)) = drop (n + (m + 1)) (head✝ :: xs)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
x✝ : List α
⊢ take 0 (take 0 x✝) = take 0 x✝
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
n✝ : ℕ
⊢ take (n✝ + 1) (take (n✝ + 1) []) = take (n✝ + 1) []
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
m : ℕ
x : α
xs : List α
⊢ take (m + 1) (take (m + 1) (x :: xs)) = take (m + 1) (x :: xs)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
x✝ : List α
⊢ take 0 x✝ ++ drop 0 x✝ = x✝
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
n✝ : ℕ
⊢ take (n✝ + 1) [] ++ drop (n✝ + 1) [] = []
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
m : ℕ
x : α
xs : List α
⊢ take (m + 1) (x :: xs) ++ drop (m + 1) (x :: xs) = x :: xs
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
C : Container
x : M C
⊢ construct (destruct x) = x
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
C : Container
x : M C
R : M C → M C → Prop := fun x y => x = construct (destruct y)
⊢ construct (destruct x) = x
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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₂ }
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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₂ }
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer I
i : I
x : M C i
⊢ construct (destruct x) = x
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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)) }
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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₂ }
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
F : Type u₁ → Type u₁
inst : QPF F
x : M F
⊢ construct (destruct x) = x
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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✝ | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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✝
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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₀) | Please generate a tactic in lean4 to solve the state.
STATE:
C : Container
α : Type u₃
f : α → Obj C α
x₀ : α
⊢ destruct (corec f x₀) = Map (corec f) (f x₀)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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₀)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
C : Container
α β : Sort u₁
i : α
j : β
h₀ : α = β
h : HEq i j
⊢ cast h₀ i = j
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
C : Container
α : Sort u₁
i : α
h₀ : α = α
⊢ cast h₀ i = i
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
case refl.h
C : Container
α : Sort u₁
i : α
h₀ : α = α
⊢ HEq (cast h₀ i) i
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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) | Please generate a tactic in lean4 to solve the state.
STATE:
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)))
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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)
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
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 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.