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/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | intro x | case h₀.Pure.refl
C : _root_.Container
R : Type u₁
x y : R
⊢ ∀ (i : Container.B (Container C R) (A.Pure x)),
eq (PEmpty.rec (fun x => M (Container C R)) i) (PEmpty.rec (fun x => M (Container C R)) i) | case h₀.Pure.refl
C : _root_.Container
R : Type u₁
x✝ y : R
x : Container.B (Container C R) (A.Pure x✝)
⊢ eq (PEmpty.rec (fun x => M (Container C R)) x) (PEmpty.rec (fun x => M (Container C R)) x) | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀.Pure.refl
C : _root_.Container
R : Type u₁
x y : R
⊢ ∀ (i : Container.B (Container C R) (A.Pure x)),
eq (PEmpty.rec (fun x => M (Container C R)) i) (PEmpty.rec (fun x => M (Container C R)) i)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | apply x.elim | case h₀.Pure.refl
C : _root_.Container
R : Type u₁
x✝ y : R
x : Container.B (Container C R) (A.Pure x✝)
⊢ eq (PEmpty.rec (fun x => M (Container C R)) x) (PEmpty.rec (fun x => M (Container C R)) x) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀.Pure.refl
C : _root_.Container
R : Type u₁
x✝ y : R
x : Container.B (Container C R) (A.Pure x✝)
⊢ eq (PEmpty.rec (fun x => M (Container C R)) x) (PEmpty.rec (fun x => M (Container C R)) x)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | exists (A.Free node) | case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) (k₁ x) (k₂ x)
⊢ ∃ node_1 k₁_1 k₂_1,
M.destruct (construct (Functor.Free node k₁)) = { fst := node_1, snd := k₁_1 } ∧
M.destruct (construct (Functor.Free node k₂)) = { fst := node_1, snd := k₂_1 } ∧
∀ (i : Container.B (Container C R) node_1), eq (k₁_1 i) (k₂_1 i) | case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) (k₁ x) (k₂ x)
⊢ ∃ k₁_1 k₂_1,
M.destruct (construct (Functor.Free node k₁)) = { fst := A.Free node, snd := k₁_1 } ∧
M.destruct (construct (Functor.Free node k₂)) = { fst := A.Free node, snd := k₂_1 } ∧
∀ (i : Container.B (Container C R) (A.Free node)), eq (k₁_1 i) (k₂_1 i) | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) (k₁ x) (k₂ x)
⊢ ∃ node_1 k₁_1 k₂_1,
M.destruct (construct (Functor.Free node k₁)) = { fst := node_1, snd := k₁_1 } ∧
M.destruct (construct (Functor.Free node k₂)) = { fst := node_1, snd := k₂_1 } ∧
∀ (i : Container.B (Container C R) node_1), eq (k₁_1 i) (k₂_1 i)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | exists k₁ | case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) (k₁ x) (k₂ x)
⊢ ∃ k₁_1 k₂_1,
M.destruct (construct (Functor.Free node k₁)) = { fst := A.Free node, snd := k₁_1 } ∧
M.destruct (construct (Functor.Free node k₂)) = { fst := A.Free node, snd := k₂_1 } ∧
∀ (i : Container.B (Container C R) (A.Free node)), eq (k₁_1 i) (k₂_1 i) | case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) (k₁ x) (k₂ x)
⊢ ∃ k₂_1,
M.destruct (construct (Functor.Free node k₁)) = { fst := A.Free node, snd := k₁ } ∧
M.destruct (construct (Functor.Free node k₂)) = { fst := A.Free node, snd := k₂_1 } ∧
∀ (i : Container.B (Container C R) (A.Free node)), eq (k₁ i) (k₂_1 i) | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) (k₁ x) (k₂ x)
⊢ ∃ k₁_1 k₂_1,
M.destruct (construct (Functor.Free node k₁)) = { fst := A.Free node, snd := k₁_1 } ∧
M.destruct (construct (Functor.Free node k₂)) = { fst := A.Free node, snd := k₂_1 } ∧
∀ (i : Container.B (Container C R) (A.Free node)), eq (k₁_1 i) (k₂_1 i)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | exists k₂ | case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) (k₁ x) (k₂ x)
⊢ ∃ k₂_1,
M.destruct (construct (Functor.Free node k₁)) = { fst := A.Free node, snd := k₁ } ∧
M.destruct (construct (Functor.Free node k₂)) = { fst := A.Free node, snd := k₂_1 } ∧
∀ (i : Container.B (Container C R) (A.Free node)), eq (k₁ i) (k₂_1 i) | case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) (k₁ x) (k₂ x)
⊢ M.destruct (construct (Functor.Free node k₁)) = { fst := A.Free node, snd := k₁ } ∧
M.destruct (construct (Functor.Free node k₂)) = { fst := A.Free node, snd := k₂ } ∧
∀ (i : Container.B (Container C R) (A.Free node)), eq (k₁ i) (k₂ i) | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) (k₁ x) (k₂ x)
⊢ ∃ k₂_1,
M.destruct (construct (Functor.Free node k₁)) = { fst := A.Free node, snd := k₁ } ∧
M.destruct (construct (Functor.Free node k₂)) = { fst := A.Free node, snd := k₂_1 } ∧
∀ (i : Container.B (Container C R) (A.Free node)), eq (k₁ i) (k₂_1 i)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | simp only [construct, M.destruct_construct, inv, true_and] | case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) (k₁ x) (k₂ x)
⊢ M.destruct (construct (Functor.Free node k₁)) = { fst := A.Free node, snd := k₁ } ∧
M.destruct (construct (Functor.Free node k₂)) = { fst := A.Free node, snd := k₂ } ∧
∀ (i : Container.B (Container C R) (A.Free node)), eq (k₁ i) (k₂ i) | case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) (k₁ x) (k₂ x)
⊢ ∀ (i : Container.B (Container C R) (A.Free node)), eq (k₁ i) (k₂ i) | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) (k₁ x) (k₂ x)
⊢ M.destruct (construct (Functor.Free node k₁)) = { fst := A.Free node, snd := k₁ } ∧
M.destruct (construct (Functor.Free node k₂)) = { fst := A.Free node, snd := k₂ } ∧
∀ (i : Container.B (Container C R) (A.Free node)), eq (k₁ i) (k₂ i)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | intro x | case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) (k₁ x) (k₂ x)
⊢ ∀ (i : Container.B (Container C R) (A.Free node)), eq (k₁ i) (k₂ i) | case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) (k₁ x) (k₂ x)
x : Container.B (Container C R) (A.Free node)
⊢ eq (k₁ x) (k₂ x) | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) (k₁ x) (k₂ x)
⊢ ∀ (i : Container.B (Container C R) (A.Free node)), eq (k₁ i) (k₂ i)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | rw [CompleteLattice.bot_sup] at h | case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) (k₁ x) (k₂ x)
x : Container.B (Container C R) (A.Free node)
⊢ eq (k₁ x) (k₂ x) | case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), ↑(pgfp (equivF' Eq)) ⊥ (k₁ x) (k₂ x)
x : Container.B (Container C R) (A.Free node)
⊢ eq (k₁ x) (k₂ x) | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), (⊥ ⊔ ↑(pgfp (equivF' Eq)) ⊥) (k₁ x) (k₂ x)
x : Container.B (Container C R) (A.Free node)
⊢ eq (k₁ x) (k₂ x)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.bisim | [136, 1] | [158, 12] | apply h | case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), ↑(pgfp (equivF' Eq)) ⊥ (k₁ x) (k₂ x)
x : Container.B (Container C R) (A.Free node)
⊢ eq (k₁ x) (k₂ x) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀.Free
C : _root_.Container
R : Type u₁
node : C.A
k₁ k₂ : Container.B C node → Free C R
h : ∀ (x : Container.B C node), ↑(pgfp (equivF' Eq)) ⊥ (k₁ x) (k₂ x)
x : Container.B (Container C R) (A.Free node)
⊢ eq (k₁ x) (k₂ x)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | have : ∀ (x y:Free C R), x = y → Free.eq x y := by
apply Free.equiv.coinduction
intro x y h
cases h
conv =>
congr
. rfl
. rfl
. rw [←construct_destruct x]
. rw [←construct_destruct x]
cases destruct x with
| Pure r =>
apply equivF.Pure
rfl
| Free node k =>
apply equivF.Free
intro y
left
rfl | C : _root_.Container
R : Type u₁
⊢ ∀ (x : Free C R), eq x x | C : _root_.Container
R : Type u₁
this : ∀ (x y : Free C R), x = y → eq x y
⊢ ∀ (x : Free C R), eq x x | Please generate a tactic in lean4 to solve the state.
STATE:
C : _root_.Container
R : Type u₁
⊢ ∀ (x : Free C R), eq x x
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | intro x | C : _root_.Container
R : Type u₁
this : ∀ (x y : Free C R), x = y → eq x y
⊢ ∀ (x : Free C R), eq x x | C : _root_.Container
R : Type u₁
this : ∀ (x y : Free C R), x = y → eq x y
x : Free C R
⊢ eq x x | Please generate a tactic in lean4 to solve the state.
STATE:
C : _root_.Container
R : Type u₁
this : ∀ (x y : Free C R), x = y → eq x y
⊢ ∀ (x : Free C R), eq x x
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | apply this | C : _root_.Container
R : Type u₁
this : ∀ (x y : Free C R), x = y → eq x y
x : Free C R
⊢ eq x x | case a
C : _root_.Container
R : Type u₁
this : ∀ (x y : Free C R), x = y → eq x y
x : Free C R
⊢ x = x | Please generate a tactic in lean4 to solve the state.
STATE:
C : _root_.Container
R : Type u₁
this : ∀ (x y : Free C R), x = y → eq x y
x : Free C R
⊢ eq x x
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | rfl | case a
C : _root_.Container
R : Type u₁
this : ∀ (x y : Free C R), x = y → eq x y
x : Free C R
⊢ x = x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
C : _root_.Container
R : Type u₁
this : ∀ (x y : Free C R), x = y → eq x y
x : Free C R
⊢ x = x
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | apply Free.equiv.coinduction | C : _root_.Container
R : Type u₁
⊢ ∀ (x y : Free C R), x = y → eq x y | case a
C : _root_.Container
R : Type u₁
⊢ ∀ (x y : Free C R), x = y → equivF Eq ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) x y | Please generate a tactic in lean4 to solve the state.
STATE:
C : _root_.Container
R : Type u₁
⊢ ∀ (x y : Free C R), x = y → eq x y
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | intro x y h | case a
C : _root_.Container
R : Type u₁
⊢ ∀ (x y : Free C R), x = y → equivF Eq ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) x y | case a
C : _root_.Container
R : Type u₁
x y : Free C R
h : x = y
⊢ equivF Eq ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) x y | Please generate a tactic in lean4 to solve the state.
STATE:
case a
C : _root_.Container
R : Type u₁
⊢ ∀ (x y : Free C R), x = y → equivF Eq ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) x y
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | cases h | case a
C : _root_.Container
R : Type u₁
x y : Free C R
h : x = y
⊢ equivF Eq ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) x y | case a.refl
C : _root_.Container
R : Type u₁
x : Free C R
⊢ equivF Eq ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) x x | Please generate a tactic in lean4 to solve the state.
STATE:
case a
C : _root_.Container
R : Type u₁
x y : Free C R
h : x = y
⊢ equivF Eq ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) x y
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | conv =>
congr
. rfl
. rfl
. rw [←construct_destruct x]
. rw [←construct_destruct x] | case a.refl
C : _root_.Container
R : Type u₁
x : Free C R
⊢ equivF Eq ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) x x | case a.refl
C : _root_.Container
R : Type u₁
x : Free C R
⊢ equivF Eq ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) (construct (destruct x)) (construct (destruct x)) | Please generate a tactic in lean4 to solve the state.
STATE:
case a.refl
C : _root_.Container
R : Type u₁
x : Free C R
⊢ equivF Eq ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) x x
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | cases destruct x with
| Pure r =>
apply equivF.Pure
rfl
| Free node k =>
apply equivF.Free
intro y
left
rfl | case a.refl
C : _root_.Container
R : Type u₁
x : Free C R
⊢ equivF Eq ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) (construct (destruct x)) (construct (destruct x)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.refl
C : _root_.Container
R : Type u₁
x : Free C R
⊢ equivF Eq ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) (construct (destruct x)) (construct (destruct x))
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | apply equivF.Pure | case a.refl.Pure
C : _root_.Container
R : Type u₁
x : Free C R
r : R
⊢ equivF Eq ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) (construct (Functor.Pure r)) (construct (Functor.Pure r)) | case a.refl.Pure.a
C : _root_.Container
R : Type u₁
x : Free C R
r : R
⊢ r = r | Please generate a tactic in lean4 to solve the state.
STATE:
case a.refl.Pure
C : _root_.Container
R : Type u₁
x : Free C R
r : R
⊢ equivF Eq ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) (construct (Functor.Pure r)) (construct (Functor.Pure r))
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | rfl | case a.refl.Pure.a
C : _root_.Container
R : Type u₁
x : Free C R
r : R
⊢ r = r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.refl.Pure.a
C : _root_.Container
R : Type u₁
x : Free C R
r : R
⊢ r = r
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | apply equivF.Free | case a.refl.Free
C : _root_.Container
R : Type u₁
x : Free C R
node : C.A
k : Container.B C node → Free C R
⊢ equivF Eq ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) (construct (Functor.Free node k))
(construct (Functor.Free node k)) | case a.refl.Free.a
C : _root_.Container
R : Type u₁
x : Free C R
node : C.A
k : Container.B C node → Free C R
⊢ ∀ (x : Container.B C node), ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) (k x) (k x) | Please generate a tactic in lean4 to solve the state.
STATE:
case a.refl.Free
C : _root_.Container
R : Type u₁
x : Free C R
node : C.A
k : Container.B C node → Free C R
⊢ equivF Eq ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) (construct (Functor.Free node k))
(construct (Functor.Free node k))
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | intro y | case a.refl.Free.a
C : _root_.Container
R : Type u₁
x : Free C R
node : C.A
k : Container.B C node → Free C R
⊢ ∀ (x : Container.B C node), ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) (k x) (k x) | case a.refl.Free.a
C : _root_.Container
R : Type u₁
x : Free C R
node : C.A
k : Container.B C node → Free C R
y : Container.B C node
⊢ ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) (k y) (k y) | Please generate a tactic in lean4 to solve the state.
STATE:
case a.refl.Free.a
C : _root_.Container
R : Type u₁
x : Free C R
node : C.A
k : Container.B C node → Free C R
⊢ ∀ (x : Container.B C node), ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) (k x) (k x)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | left | case a.refl.Free.a
C : _root_.Container
R : Type u₁
x : Free C R
node : C.A
k : Container.B C node → Free C R
y : Container.B C node
⊢ ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) (k y) (k y) | case a.refl.Free.a.h
C : _root_.Container
R : Type u₁
x : Free C R
node : C.A
k : Container.B C node → Free C R
y : Container.B C node
⊢ (fun x y => x = y) (k y) (k y) | Please generate a tactic in lean4 to solve the state.
STATE:
case a.refl.Free.a
C : _root_.Container
R : Type u₁
x : Free C R
node : C.A
k : Container.B C node → Free C R
y : Container.B C node
⊢ ((fun x y => x = y) ⊔ pequiv Eq fun x y => x = y) (k y) (k y)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.eq.rfl | [161, 1] | [183, 6] | rfl | case a.refl.Free.a.h
C : _root_.Container
R : Type u₁
x : Free C R
node : C.A
k : Container.B C node → Free C R
y : Container.B C node
⊢ (fun x y => x = y) (k y) (k y) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.refl.Free.a.h
C : _root_.Container
R : Type u₁
x : Free C R
node : C.A
k : Container.B C node → Free C R
y : Container.B C node
⊢ (fun x y => x = y) (k y) (k y)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | apply Free.eq.bisim | C : _root_.Container
R S : Type u₁
f : R → Free C S
x : Free C S
⊢ corec (bind.automaton f) (Sum.inr x) = x | case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x : Free C S
⊢ eq (corec (bind.automaton f) (Sum.inr x)) x | Please generate a tactic in lean4 to solve the state.
STATE:
C : _root_.Container
R S : Type u₁
f : R → Free C S
x : Free C S
⊢ corec (bind.automaton f) (Sum.inr x) = x
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | have : ∀ x y, x = corec (bind.automaton f) (.inr y) → eq x y := by
apply Free.equiv.coinduction
intro x y h₁
conv =>
congr
. rfl
. rfl
. rw [←construct_destruct x]
. rw [←construct_destruct y]
have h₂ := congrArg destruct h₁
clear h₁
rw [destruct_corec] at h₂
cases hy: destruct y with
| Pure r =>
simp only [Map, hy, bind.automaton] at h₂
rw [h₂]
apply equivF.Pure
rfl
| Free n k =>
simp only [Map, bind.automaton, hy] at h₂
rw [h₂]
apply equivF.Free
intro y
left
rfl | case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x : Free C S
⊢ eq (corec (bind.automaton f) (Sum.inr x)) x | case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x : Free C S
this : ∀ (x y : Free C S), x = corec (bind.automaton f) (Sum.inr y) → eq x y
⊢ eq (corec (bind.automaton f) (Sum.inr x)) x | Please generate a tactic in lean4 to solve the state.
STATE:
case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x : Free C S
⊢ eq (corec (bind.automaton f) (Sum.inr x)) x
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | apply this | case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x : Free C S
this : ∀ (x y : Free C S), x = corec (bind.automaton f) (Sum.inr y) → eq x y
⊢ eq (corec (bind.automaton f) (Sum.inr x)) x | case a.a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x : Free C S
this : ∀ (x y : Free C S), x = corec (bind.automaton f) (Sum.inr y) → eq x y
⊢ corec (bind.automaton f) (Sum.inr x) = corec (bind.automaton f) (Sum.inr x) | Please generate a tactic in lean4 to solve the state.
STATE:
case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x : Free C S
this : ∀ (x y : Free C S), x = corec (bind.automaton f) (Sum.inr y) → eq x y
⊢ eq (corec (bind.automaton f) (Sum.inr x)) x
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | rfl | case a.a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x : Free C S
this : ∀ (x y : Free C S), x = corec (bind.automaton f) (Sum.inr y) → eq x y
⊢ corec (bind.automaton f) (Sum.inr x) = corec (bind.automaton f) (Sum.inr x) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x : Free C S
this : ∀ (x y : Free C S), x = corec (bind.automaton f) (Sum.inr y) → eq x y
⊢ corec (bind.automaton f) (Sum.inr x) = corec (bind.automaton f) (Sum.inr x)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | apply Free.equiv.coinduction | C : _root_.Container
R S : Type u₁
f : R → Free C S
x : Free C S
⊢ ∀ (x y : Free C S), x = corec (bind.automaton f) (Sum.inr y) → eq x y | case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x : Free C S
⊢ ∀ (x y : Free C S),
x = corec (bind.automaton f) (Sum.inr y) →
equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
x y | Please generate a tactic in lean4 to solve the state.
STATE:
C : _root_.Container
R S : Type u₁
f : R → Free C S
x : Free C S
⊢ ∀ (x y : Free C S), x = corec (bind.automaton f) (Sum.inr y) → eq x y
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | intro x y h₁ | case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x : Free C S
⊢ ∀ (x y : Free C S),
x = corec (bind.automaton f) (Sum.inr y) →
equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
x y | case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₁ : x = corec (bind.automaton f) (Sum.inr y)
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
x y | Please generate a tactic in lean4 to solve the state.
STATE:
case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x : Free C S
⊢ ∀ (x y : Free C S),
x = corec (bind.automaton f) (Sum.inr y) →
equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
x y
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | conv =>
congr
. rfl
. rfl
. rw [←construct_destruct x]
. rw [←construct_destruct y] | case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₁ : x = corec (bind.automaton f) (Sum.inr y)
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
x y | case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₁ : x = corec (bind.automaton f) (Sum.inr y)
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y)) | Please generate a tactic in lean4 to solve the state.
STATE:
case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₁ : x = corec (bind.automaton f) (Sum.inr y)
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
x y
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | have h₂ := congrArg destruct h₁ | case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₁ : x = corec (bind.automaton f) (Sum.inr y)
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y)) | case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₁ : x = corec (bind.automaton f) (Sum.inr y)
h₂ : destruct x = destruct (corec (bind.automaton f) (Sum.inr y))
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y)) | Please generate a tactic in lean4 to solve the state.
STATE:
case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₁ : x = corec (bind.automaton f) (Sum.inr y)
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y))
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | clear h₁ | case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₁ : x = corec (bind.automaton f) (Sum.inr y)
h₂ : destruct x = destruct (corec (bind.automaton f) (Sum.inr y))
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y)) | case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₂ : destruct x = destruct (corec (bind.automaton f) (Sum.inr y))
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y)) | Please generate a tactic in lean4 to solve the state.
STATE:
case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₁ : x = corec (bind.automaton f) (Sum.inr y)
h₂ : destruct x = destruct (corec (bind.automaton f) (Sum.inr y))
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y))
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | rw [destruct_corec] at h₂ | case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₂ : destruct x = destruct (corec (bind.automaton f) (Sum.inr y))
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y)) | case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₂ : destruct x = Map (corec (bind.automaton f)) (bind.automaton f (Sum.inr y))
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y)) | Please generate a tactic in lean4 to solve the state.
STATE:
case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₂ : destruct x = destruct (corec (bind.automaton f) (Sum.inr y))
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y))
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | cases hy: destruct y with
| Pure r =>
simp only [Map, hy, bind.automaton] at h₂
rw [h₂]
apply equivF.Pure
rfl
| Free n k =>
simp only [Map, bind.automaton, hy] at h₂
rw [h₂]
apply equivF.Free
intro y
left
rfl | case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₂ : destruct x = Map (corec (bind.automaton f)) (bind.automaton f (Sum.inr y))
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₂ : destruct x = Map (corec (bind.automaton f)) (bind.automaton f (Sum.inr y))
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (destruct y))
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | simp only [Map, hy, bind.automaton] at h₂ | case a.Pure
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₂ : destruct x = Map (corec (bind.automaton f)) (bind.automaton f (Sum.inr y))
r : S
hy : destruct y = Functor.Pure r
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (Functor.Pure r)) | case a.Pure
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
r : S
hy : destruct y = Functor.Pure r
h₂ : destruct x = Functor.Pure r
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (Functor.Pure r)) | Please generate a tactic in lean4 to solve the state.
STATE:
case a.Pure
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₂ : destruct x = Map (corec (bind.automaton f)) (bind.automaton f (Sum.inr y))
r : S
hy : destruct y = Functor.Pure r
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (Functor.Pure r))
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | rw [h₂] | case a.Pure
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
r : S
hy : destruct y = Functor.Pure r
h₂ : destruct x = Functor.Pure r
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (Functor.Pure r)) | case a.Pure
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
r : S
hy : destruct y = Functor.Pure r
h₂ : destruct x = Functor.Pure r
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (Functor.Pure r)) (construct (Functor.Pure r)) | Please generate a tactic in lean4 to solve the state.
STATE:
case a.Pure
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
r : S
hy : destruct y = Functor.Pure r
h₂ : destruct x = Functor.Pure r
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (Functor.Pure r))
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | apply equivF.Pure | case a.Pure
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
r : S
hy : destruct y = Functor.Pure r
h₂ : destruct x = Functor.Pure r
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (Functor.Pure r)) (construct (Functor.Pure r)) | case a.Pure.a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
r : S
hy : destruct y = Functor.Pure r
h₂ : destruct x = Functor.Pure r
⊢ r = r | Please generate a tactic in lean4 to solve the state.
STATE:
case a.Pure
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
r : S
hy : destruct y = Functor.Pure r
h₂ : destruct x = Functor.Pure r
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (Functor.Pure r)) (construct (Functor.Pure r))
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | rfl | case a.Pure.a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
r : S
hy : destruct y = Functor.Pure r
h₂ : destruct x = Functor.Pure r
⊢ r = r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.Pure.a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
r : S
hy : destruct y = Functor.Pure r
h₂ : destruct x = Functor.Pure r
⊢ r = r
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | simp only [Map, bind.automaton, hy] at h₂ | case a.Free
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₂ : destruct x = Map (corec (bind.automaton f)) (bind.automaton f (Sum.inr y))
n : C.A
k : Container.B C n → Free C S
hy : destruct y = Functor.Free n k
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (Functor.Free n k)) | case a.Free
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
n : C.A
k : Container.B C n → Free C S
hy : destruct y = Functor.Free n k
h₂ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (Functor.Free n k)) | Please generate a tactic in lean4 to solve the state.
STATE:
case a.Free
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
h₂ : destruct x = Map (corec (bind.automaton f)) (bind.automaton f (Sum.inr y))
n : C.A
k : Container.B C n → Free C S
hy : destruct y = Functor.Free n k
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (Functor.Free n k))
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | rw [h₂] | case a.Free
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
n : C.A
k : Container.B C n → Free C S
hy : destruct y = Functor.Free n k
h₂ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (Functor.Free n k)) | case a.Free
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
n : C.A
k : Container.B C n → Free C S
hy : destruct y = Functor.Free n k
h₂ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct
(Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)))
(construct (Functor.Free n k)) | Please generate a tactic in lean4 to solve the state.
STATE:
case a.Free
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
n : C.A
k : Container.B C n → Free C S
hy : destruct y = Functor.Free n k
h₂ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct (destruct x)) (construct (Functor.Free n k))
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | apply equivF.Free | case a.Free
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
n : C.A
k : Container.B C n → Free C S
hy : destruct y = Functor.Free n k
h₂ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct
(Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)))
(construct (Functor.Free n k)) | case a.Free.a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
n : C.A
k : Container.B C n → Free C S
hy : destruct y = Functor.Free n k
h₂ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
⊢ ∀ (x : Container.B C n),
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
x)
(k x) | Please generate a tactic in lean4 to solve the state.
STATE:
case a.Free
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
n : C.A
k : Container.B C n → Free C S
hy : destruct y = Functor.Free n k
h₂ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
⊢ equivF Eq
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(construct
(Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)))
(construct (Functor.Free n k))
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | intro y | case a.Free.a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
n : C.A
k : Container.B C n → Free C S
hy : destruct y = Functor.Free n k
h₂ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
⊢ ∀ (x : Container.B C n),
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
x)
(k x) | case a.Free.a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y✝ : Free C S
n : C.A
k : Container.B C n → Free C S
hy : destruct y✝ = Functor.Free n k
h₂ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
y : Container.B C n
⊢ ((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
y)
(k y) | Please generate a tactic in lean4 to solve the state.
STATE:
case a.Free.a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y : Free C S
n : C.A
k : Container.B C n → Free C S
hy : destruct y = Functor.Free n k
h₂ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
⊢ ∀ (x : Container.B C n),
((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
x)
(k x)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | left | case a.Free.a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y✝ : Free C S
n : C.A
k : Container.B C n → Free C S
hy : destruct y✝ = Functor.Free n k
h₂ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
y : Container.B C n
⊢ ((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
y)
(k y) | case a.Free.a.h
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y✝ : Free C S
n : C.A
k : Container.B C n → Free C S
hy : destruct y✝ = Functor.Free n k
h₂ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
y : Container.B C n
⊢ (fun x y => x = corec (bind.automaton f) (Sum.inr y))
(((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
y)
(k y) | Please generate a tactic in lean4 to solve the state.
STATE:
case a.Free.a
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y✝ : Free C S
n : C.A
k : Container.B C n → Free C S
hy : destruct y✝ = Functor.Free n k
h₂ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
y : Container.B C n
⊢ ((fun x y => x = corec (bind.automaton f) (Sum.inr y)) ⊔
pequiv Eq fun x y => x = corec (bind.automaton f) (Sum.inr y))
(((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
y)
(k y)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_inr | [199, 1] | [228, 6] | rfl | case a.Free.a.h
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y✝ : Free C S
n : C.A
k : Container.B C n → Free C S
hy : destruct y✝ = Functor.Free n k
h₂ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
y : Container.B C n
⊢ (fun x y => x = corec (bind.automaton f) (Sum.inr y))
(((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
y)
(k y) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.Free.a.h
C : _root_.Container
R S : Type u₁
f : R → Free C S
x✝ x y✝ : Free C S
n : C.A
k : Container.B C n → Free C S
hy : destruct y✝ = Functor.Free n k
h₂ :
destruct x =
Functor.Free n
((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
y : Container.B C n
⊢ (fun x y => x = corec (bind.automaton f) (Sum.inr y))
(((corec fun x =>
match x with
| Sum.inr x =>
match destruct x with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Sum.inl x =>
match destruct x with
| Functor.Pure r =>
match destruct (f r) with
| Functor.Pure r => Functor.Pure r
| Functor.Free node k => Functor.Free node (Sum.inr ∘ k)
| Functor.Free n k => Functor.Free n (Sum.inl ∘ k)) ∘
Sum.inr ∘ k)
y)
(k y)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | rw [←construct_destruct <| k r] | C : _root_.Container
R S : Type u₁
r : R
k : R → Free C S
⊢ bind (pure r) k = k r | C : _root_.Container
R S : Type u₁
r : R
k : R → Free C S
⊢ bind (pure r) k = construct (destruct (k r)) | Please generate a tactic in lean4 to solve the state.
STATE:
C : _root_.Container
R S : Type u₁
r : R
k : R → Free C S
⊢ bind (pure r) k = k r
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | rw [←construct_destruct <| bind (pure r) k] | C : _root_.Container
R S : Type u₁
r : R
k : R → Free C S
⊢ bind (pure r) k = construct (destruct (k r)) | C : _root_.Container
R S : Type u₁
r : R
k : R → Free C S
⊢ construct (destruct (bind (pure r) k)) = construct (destruct (k r)) | Please generate a tactic in lean4 to solve the state.
STATE:
C : _root_.Container
R S : Type u₁
r : R
k : R → Free C S
⊢ bind (pure r) k = construct (destruct (k r))
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | simp only [bind, pure, destruct_corec] | C : _root_.Container
R S : Type u₁
r : R
k : R → Free C S
⊢ construct (destruct (bind (pure r) k)) = construct (destruct (k r)) | C : _root_.Container
R S : Type u₁
r : R
k : R → Free C S
⊢ construct (Map (corec (bind.automaton k)) (bind.automaton k (Sum.inl (construct (Functor.Pure r))))) =
construct (destruct (k r)) | Please generate a tactic in lean4 to solve the state.
STATE:
C : _root_.Container
R S : Type u₁
r : R
k : R → Free C S
⊢ construct (destruct (bind (pure r) k)) = construct (destruct (k r))
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | apply congrArg construct | C : _root_.Container
R S : Type u₁
r : R
k : R → Free C S
⊢ construct (Map (corec (bind.automaton k)) (bind.automaton k (Sum.inl (construct (Functor.Pure r))))) =
construct (destruct (k r)) | C : _root_.Container
R S : Type u₁
r : R
k : R → Free C S
⊢ Map (corec (bind.automaton k)) (bind.automaton k (Sum.inl (construct (Functor.Pure r)))) = destruct (k r) | Please generate a tactic in lean4 to solve the state.
STATE:
C : _root_.Container
R S : Type u₁
r : R
k : R → Free C S
⊢ construct (Map (corec (bind.automaton k)) (bind.automaton k (Sum.inl (construct (Functor.Pure r))))) =
construct (destruct (k r))
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | conv =>
lhs
congr
. rfl
. simp only [bind.automaton, destruct_construct] | C : _root_.Container
R S : Type u₁
r : R
k : R → Free C S
⊢ Map (corec (bind.automaton k)) (bind.automaton k (Sum.inl (construct (Functor.Pure r)))) = destruct (k r) | C : _root_.Container
R S : Type u₁
r : R
k : R → Free C S
⊢ Map (corec (bind.automaton k)) (Map Sum.inr (destruct (k r))) = destruct (k r) | Please generate a tactic in lean4 to solve the state.
STATE:
C : _root_.Container
R S : Type u₁
r : R
k : R → Free C S
⊢ Map (corec (bind.automaton k)) (bind.automaton k (Sum.inl (construct (Functor.Pure r)))) = destruct (k r)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | cases destruct (k r) with
| Pure r =>
simp only [Map]
| Free n k =>
simp only [Map]
conv =>
lhs
congr
simp only [Function.comp]
intro x
rw [bind_inr] | C : _root_.Container
R S : Type u₁
r : R
k : R → Free C S
⊢ Map (corec (bind.automaton k)) (Map Sum.inr (destruct (k r))) = destruct (k r) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
C : _root_.Container
R S : Type u₁
r : R
k : R → Free C S
⊢ Map (corec (bind.automaton k)) (Map Sum.inr (destruct (k r))) = destruct (k r)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | simp only [Map] | case Pure
C : _root_.Container
R S : Type u₁
r✝ : R
k : R → Free C S
r : S
⊢ Map (corec (bind.automaton k)) (Map Sum.inr (Functor.Pure r)) = Functor.Pure r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case Pure
C : _root_.Container
R S : Type u₁
r✝ : R
k : R → Free C S
r : S
⊢ Map (corec (bind.automaton k)) (Map Sum.inr (Functor.Pure r)) = Functor.Pure r
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | simp only [Map] | case Free
C : _root_.Container
R S : Type u₁
r : R
k✝ : R → Free C S
n : C.A
k : Container.B C n → Free C S
⊢ Map (corec (bind.automaton k✝)) (Map Sum.inr (Functor.Free n k)) = Functor.Free n k | case Free
C : _root_.Container
R S : Type u₁
r : R
k✝ : R → Free C S
n : C.A
k : Container.B C n → Free C S
⊢ Functor.Free n (corec (bind.automaton k✝) ∘ Sum.inr ∘ k) = Functor.Free n k | Please generate a tactic in lean4 to solve the state.
STATE:
case Free
C : _root_.Container
R S : Type u₁
r : R
k✝ : R → Free C S
n : C.A
k : Container.B C n → Free C S
⊢ Map (corec (bind.automaton k✝)) (Map Sum.inr (Functor.Free n k)) = Functor.Free n k
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/FreeMonads.lean | Free.bind_pure | [230, 1] | [251, 20] | conv =>
lhs
congr
simp only [Function.comp]
intro x
rw [bind_inr] | case Free
C : _root_.Container
R S : Type u₁
r : R
k✝ : R → Free C S
n : C.A
k : Container.B C n → Free C S
⊢ Functor.Free n (corec (bind.automaton k✝) ∘ Sum.inr ∘ k) = Functor.Free n k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case Free
C : _root_.Container
R S : Type u₁
r : R
k✝ : R → Free C S
n : C.A
k : Container.B C n → Free C S
⊢ Functor.Free n (corec (bind.automaton k✝) ∘ Sum.inr ∘ k) = Functor.Free n k
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.wf_destruct | [72, 1] | [79, 10] | simp only [WellFormed, PWellFormed] at wf | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : WellFormed i m
⊢ ∀ (x : B C (Container.M.destruct ↑{ val := m, property := wf }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := m, property := wf }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf }) x) | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : ↑(pgfp (WellFormedF C)) ⊥ i m
⊢ ∀ (x : B C (Container.M.destruct ↑{ val := m, property := wf }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := m, property := wf }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf }) x) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : WellFormed i m
⊢ ∀ (x : B C (Container.M.destruct ↑{ val := m, property := wf }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := m, property := wf }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf }) x)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.wf_destruct | [72, 1] | [79, 10] | rw [←pgfp.unfold] at wf | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : ↑(pgfp (WellFormedF C)) ⊥ i m
⊢ ∀ (x : B C (Container.M.destruct ↑{ val := m, property := wf }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := m, property := wf }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf }) x) | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (⊥ ⊔ ↑(pgfp (WellFormedF C)) ⊥) i m
⊢ ∀ (x : B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : ↑(pgfp (WellFormedF C)) ⊥ i m
⊢ ∀ (x : B C (Container.M.destruct ↑{ val := m, property := wf }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := m, property := wf }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf }) x)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.wf_destruct | [72, 1] | [79, 10] | simp only [CompleteLattice.bot_sup] at wf | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (⊥ ⊔ ↑(pgfp (WellFormedF C)) ⊥) i m
⊢ ∀ (x : B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x) | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
⊢ ∀ (x : B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (⊥ ⊔ ↑(pgfp (WellFormedF C)) ⊥) i m
⊢ ∀ (x : B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.wf_destruct | [72, 1] | [79, 10] | have ⟨_, y⟩ := wf | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
⊢ ∀ (x : B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x) | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
left✝ : Idx C (Container.M.destruct m).fst = i
y :
∀ (x : B C (Container.M.destruct m).fst),
↑(pgfp (WellFormedF C)) ⊥ (Next C (Container.M.destruct m).fst x) (PSigma.snd (Container.M.destruct m) x)
⊢ ∀ (x : B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
⊢ ∀ (x : B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.wf_destruct | [72, 1] | [79, 10] | exact y | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
left✝ : Idx C (Container.M.destruct m).fst = i
y :
∀ (x : B C (Container.M.destruct m).fst),
↑(pgfp (WellFormedF C)) ⊥ (Next C (Container.M.destruct m).fst x) (PSigma.snd (Container.M.destruct m) x)
⊢ ∀ (x : B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
left✝ : Idx C (Container.M.destruct m).fst = i
y :
∀ (x : B C (Container.M.destruct m).fst),
↑(pgfp (WellFormedF C)) ⊥ (Next C (Container.M.destruct m).fst x) (PSigma.snd (Container.M.destruct m) x)
⊢ ∀ (x : B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.index_destruct | [81, 1] | [88, 10] | simp only [WellFormed, PWellFormed] at wf | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : WellFormed i m
⊢ i = Idx C (Container.M.destruct ↑{ val := m, property := wf }).fst | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : ↑(pgfp (WellFormedF C)) ⊥ i m
⊢ i = Idx C (Container.M.destruct ↑{ val := m, property := wf }).fst | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : WellFormed i m
⊢ i = Idx C (Container.M.destruct ↑{ val := m, property := wf }).fst
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.index_destruct | [81, 1] | [88, 10] | rw [←pgfp.unfold] at wf | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : ↑(pgfp (WellFormedF C)) ⊥ i m
⊢ i = Idx C (Container.M.destruct ↑{ val := m, property := wf }).fst | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (⊥ ⊔ ↑(pgfp (WellFormedF C)) ⊥) i m
⊢ i = Idx C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : ↑(pgfp (WellFormedF C)) ⊥ i m
⊢ i = Idx C (Container.M.destruct ↑{ val := m, property := wf }).fst
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.index_destruct | [81, 1] | [88, 10] | simp only [CompleteLattice.bot_sup] at wf | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (⊥ ⊔ ↑(pgfp (WellFormedF C)) ⊥) i m
⊢ i = Idx C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
⊢ i = Idx C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (⊥ ⊔ ↑(pgfp (WellFormedF C)) ⊥) i m
⊢ i = Idx C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.index_destruct | [81, 1] | [88, 10] | have ⟨x, _⟩ := wf | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
⊢ i = Idx C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
x : Idx C (Container.M.destruct m).fst = i
right✝ :
∀ (x : B C (Container.M.destruct m).fst),
↑(pgfp (WellFormedF C)) ⊥ (Next C (Container.M.destruct m).fst x) (PSigma.snd (Container.M.destruct m) x)
⊢ i = Idx C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
⊢ i = Idx C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.index_destruct | [81, 1] | [88, 10] | apply Eq.symm | I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
x : Idx C (Container.M.destruct m).fst = i
right✝ :
∀ (x : B C (Container.M.destruct m).fst),
↑(pgfp (WellFormedF C)) ⊥ (Next C (Container.M.destruct m).fst x) (PSigma.snd (Container.M.destruct m) x)
⊢ i = Idx C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst | case h
I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
x : Idx C (Container.M.destruct m).fst = i
right✝ :
∀ (x : B C (Container.M.destruct m).fst),
↑(pgfp (WellFormedF C)) ⊥ (Next C (Container.M.destruct m).fst x) (PSigma.snd (Container.M.destruct m) x)
⊢ Idx C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst = i | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
x : Idx C (Container.M.destruct m).fst = i
right✝ :
∀ (x : B C (Container.M.destruct m).fst),
↑(pgfp (WellFormedF C)) ⊥ (Next C (Container.M.destruct m).fst x) (PSigma.snd (Container.M.destruct m) x)
⊢ i = Idx C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.index_destruct | [81, 1] | [88, 10] | exact x | case h
I : Type u₀
C : IContainer' I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
x : Idx C (Container.M.destruct m).fst = i
right✝ :
∀ (x : B C (Container.M.destruct m).fst),
↑(pgfp (WellFormedF C)) ⊥ (Next C (Container.M.destruct m).fst x) (PSigma.snd (Container.M.destruct m) x)
⊢ Idx C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst = i | no goals | 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
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
x : Idx C (Container.M.destruct m).fst = i
right✝ :
∀ (x : B C (Container.M.destruct m).fst),
↑(pgfp (WellFormedF C)) ⊥ (Next C (Container.M.destruct m).fst x) (PSigma.snd (Container.M.destruct m) x)
⊢ Idx C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst = i
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | intro ⟨x, wfx⟩ ⟨y, wfy⟩ h₁ | I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
⊢ ∀ (x y : M C i), R i x y → x = y | I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ { val := x, property := wfx } = { val := y, property := wfy } | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
⊢ ∀ (x y : M C i), R i x y → x = y
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | suffices h: x = y by
induction h
rfl | I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ { val := x, property := wfx } = { val := y, property := wfy } | I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ x = y | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ { val := x, property := wfx } = { val := y, property := wfy }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | apply Container.M.bisim (λ x y => ∃ i, ∃ (wfx: WellFormed i x) (wfy:WellFormed i y), R i ⟨x, wfx⟩ ⟨y, wfy⟩) | I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ x = y | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∀ (x y : Container.M (toContainer C)),
(∃ i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy }) →
∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy }
case a
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∃ i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy } | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ x = y
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | . intro x y ⟨i, wfx, wfy, r⟩
have ⟨⟨node, h₄⟩, k₁, k₂, h₁, h₂, h₃⟩ := h₀ i ⟨x, wfx⟩ ⟨y, wfy⟩ r
have h₁ := lift_destruct_eq _ _ _ _ h₁
have h₂ := lift_destruct_eq _ _ _ _ h₂
have wfx' := wf_destruct ⟨x, wfx⟩
have wfy' := wf_destruct ⟨y, wfy⟩
exists node
exists λ a => (k₁ a).1
exists λ x => (k₂ x).1
simp only [h₁, h₂, true_and]
intro a
exists C.Next node a
simp only [toContainer] at a
exists (by
rw [h₁] at wfx'
apply wfx'
)
exists (by
rw [h₂] at wfy'
apply wfy'
)
exact h₃ a | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∀ (x y : Container.M (toContainer C)),
(∃ i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy }) →
∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy }
case a
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∃ i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy } | case a
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∃ i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy } | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∀ (x y : Container.M (toContainer C)),
(∃ i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy }) →
∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy }
case a
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∃ i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists i | case a
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∃ i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy } | case a
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∃ wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy } | Please generate a tactic in lean4 to solve the state.
STATE:
case a
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∃ i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists wfx | case a
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∃ wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy } | case a
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∃ wfy, R i { val := x, property := wfx } { val := y, property := wfy } | Please generate a tactic in lean4 to solve the state.
STATE:
case a
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∃ wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists wfy | case a
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∃ wfy, R i { val := x, property := wfx } { val := y, property := wfy } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∃ wfy, R i { val := x, property := wfx } { val := y, property := wfy }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | induction h | I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
h : x = y
⊢ { val := x, property := wfx } = { val := y, property := wfy } | case refl
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i x
h₁ : R i { val := x, property := wfx } { val := x, property := wfy }
⊢ { val := x, property := wfx } = { val := x, property := wfy } | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
h : x = y
⊢ { val := x, property := wfx } = { val := y, property := wfy }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | rfl | case refl
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i x
h₁ : R i { val := x, property := wfx } { val := x, property := wfy }
⊢ { val := x, property := wfx } = { val := x, property := wfy } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i x
h₁ : R i { val := x, property := wfx } { val := x, property := wfy }
⊢ { val := x, property := wfx } = { val := x, property := wfy }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | intro x y ⟨i, wfx, wfy, r⟩ | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∀ (x y : Container.M (toContainer C)),
(∃ i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy }) →
∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy } | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy } | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i : I
x : Container.M (toContainer C)
wfx : WellFormed i x
y : Container.M (toContainer C)
wfy : WellFormed i y
h₁ : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∀ (x y : Container.M (toContainer C)),
(∃ i wfx wfy, R i { val := x, property := wfx } { val := y, property := wfy }) →
∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | have ⟨⟨node, h₄⟩, k₁, k₂, h₁, h₂, h₃⟩ := h₀ i ⟨x, wfx⟩ ⟨y, wfy⟩ r | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy } | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy } | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | have h₁ := lift_destruct_eq _ _ _ _ h₁ | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy } | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy } | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | have h₂ := lift_destruct_eq _ _ _ _ h₂ | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy } | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy } | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | have wfx' := wf_destruct ⟨x, wfx⟩ | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy } | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy } | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | have wfy' := wf_destruct ⟨y, wfy⟩ | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy } | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy } | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists node | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy } | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
⊢ ∃ k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy } | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
⊢ ∃ node k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists λ a => (k₁ a).1 | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
⊢ ∃ k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy } | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
⊢ ∃ k₂,
Container.M.destruct x = { fst := node, snd := fun a => ↑(k₁ a) } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i_1 : Container.B (toContainer C) node),
∃ i_2 wfx wfy, R i_2 { val := (fun a => ↑(k₁ a)) i_1, property := wfx } { val := k₂ i_1, property := wfy } | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
⊢ ∃ k₁ k₂,
Container.M.destruct x = { fst := node, snd := k₁ } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i : Container.B (toContainer C) node),
∃ i_1 wfx wfy, R i_1 { val := k₁ i, property := wfx } { val := k₂ i, property := wfy }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists λ x => (k₂ x).1 | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
⊢ ∃ k₂,
Container.M.destruct x = { fst := node, snd := fun a => ↑(k₁ a) } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i_1 : Container.B (toContainer C) node),
∃ i_2 wfx wfy, R i_2 { val := (fun a => ↑(k₁ a)) i_1, property := wfx } { val := k₂ i_1, property := wfy } | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
⊢ Container.M.destruct x = { fst := node, snd := fun a => ↑(k₁ a) } ∧
Container.M.destruct y = { fst := node, snd := fun x => ↑(k₂ x) } ∧
∀ (i_1 : Container.B (toContainer C) node),
∃ i_2 wfx wfy,
R i_2 { val := (fun a => ↑(k₁ a)) i_1, property := wfx } { val := (fun x => ↑(k₂ x)) i_1, property := wfy } | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
⊢ ∃ k₂,
Container.M.destruct x = { fst := node, snd := fun a => ↑(k₁ a) } ∧
Container.M.destruct y = { fst := node, snd := k₂ } ∧
∀ (i_1 : Container.B (toContainer C) node),
∃ i_2 wfx wfy, R i_2 { val := (fun a => ↑(k₁ a)) i_1, property := wfx } { val := k₂ i_1, property := wfy }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | simp only [h₁, h₂, true_and] | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
⊢ Container.M.destruct x = { fst := node, snd := fun a => ↑(k₁ a) } ∧
Container.M.destruct y = { fst := node, snd := fun x => ↑(k₂ x) } ∧
∀ (i_1 : Container.B (toContainer C) node),
∃ i_2 wfx wfy,
R i_2 { val := (fun a => ↑(k₁ a)) i_1, property := wfx } { val := (fun x => ↑(k₂ x)) i_1, property := wfy } | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
⊢ ∀ (i_1 : Container.B (toContainer C) node),
∃ i_2 h h_1,
R i_2 { val := ↑(k₁ i_1), property := (_ : WellFormed i_2 ((fun a => ↑(k₁ a)) i_1)) }
{ val := ↑(k₂ i_1), property := (_ : WellFormed i_2 ((fun x => ↑(k₂ x)) i_1)) } | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
⊢ Container.M.destruct x = { fst := node, snd := fun a => ↑(k₁ a) } ∧
Container.M.destruct y = { fst := node, snd := fun x => ↑(k₂ x) } ∧
∀ (i_1 : Container.B (toContainer C) node),
∃ i_2 wfx wfy,
R i_2 { val := (fun a => ↑(k₁ a)) i_1, property := wfx } { val := (fun x => ↑(k₂ x)) i_1, property := wfy }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | intro a | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
⊢ ∀ (i_1 : Container.B (toContainer C) node),
∃ i_2 h h_1,
R i_2 { val := ↑(k₁ i_1), property := (_ : WellFormed i_2 ((fun a => ↑(k₁ a)) i_1)) }
{ val := ↑(k₂ i_1), property := (_ : WellFormed i_2 ((fun x => ↑(k₂ x)) i_1)) } | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : Container.B (toContainer C) node
⊢ ∃ i_1 h h_1,
R i_1 { val := ↑(k₁ a), property := (_ : WellFormed i_1 ((fun a => ↑(k₁ a)) a)) }
{ val := ↑(k₂ a), property := (_ : WellFormed i_1 ((fun x => ↑(k₂ x)) a)) } | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
⊢ ∀ (i_1 : Container.B (toContainer C) node),
∃ i_2 h h_1,
R i_2 { val := ↑(k₁ i_1), property := (_ : WellFormed i_2 ((fun a => ↑(k₁ a)) i_1)) }
{ val := ↑(k₂ i_1), property := (_ : WellFormed i_2 ((fun x => ↑(k₂ x)) i_1)) }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists C.Next node a | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : Container.B (toContainer C) node
⊢ ∃ i_1 h h_1,
R i_1 { val := ↑(k₁ a), property := (_ : WellFormed i_1 ((fun a => ↑(k₁ a)) a)) }
{ val := ↑(k₂ a), property := (_ : WellFormed i_1 ((fun x => ↑(k₂ x)) a)) } | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : Container.B (toContainer C) node
⊢ ∃ h h_1,
R (Next C node a) { val := ↑(k₁ a), property := (_ : WellFormed (Next C node a) ((fun a => ↑(k₁ a)) a)) }
{ val := ↑(k₂ a), property := (_ : WellFormed (Next C node a) ((fun x => ↑(k₂ x)) a)) } | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : Container.B (toContainer C) node
⊢ ∃ i_1 h h_1,
R i_1 { val := ↑(k₁ a), property := (_ : WellFormed i_1 ((fun a => ↑(k₁ a)) a)) }
{ val := ↑(k₂ a), property := (_ : WellFormed i_1 ((fun x => ↑(k₂ x)) a)) }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | simp only [toContainer] at a | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : Container.B (toContainer C) node
⊢ ∃ h h_1,
R (Next C node a) { val := ↑(k₁ a), property := (_ : WellFormed (Next C node a) ((fun a => ↑(k₁ a)) a)) }
{ val := ↑(k₂ a), property := (_ : WellFormed (Next C node a) ((fun x => ↑(k₂ x)) a)) } | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : B C node
⊢ ∃ h h_1,
R (Next C node a) { val := ↑(k₁ a), property := (_ : WellFormed (Next C node a) ((fun a => ↑(k₁ a)) a)) }
{ val := ↑(k₂ a), property := (_ : WellFormed (Next C node a) ((fun x => ↑(k₂ x)) a)) } | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : Container.B (toContainer C) node
⊢ ∃ h h_1,
R (Next C node a) { val := ↑(k₁ a), property := (_ : WellFormed (Next C node a) ((fun a => ↑(k₁ a)) a)) }
{ val := ↑(k₂ a), property := (_ : WellFormed (Next C node a) ((fun x => ↑(k₂ x)) a)) }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists (by
rw [h₁] at wfx'
apply wfx'
) | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : B C node
⊢ ∃ h h_1,
R (Next C node a) { val := ↑(k₁ a), property := (_ : WellFormed (Next C node a) ((fun a => ↑(k₁ a)) a)) }
{ val := ↑(k₂ a), property := (_ : WellFormed (Next C node a) ((fun x => ↑(k₂ x)) a)) } | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : B C node
⊢ ∃ h,
R (Next C node a) { val := ↑(k₁ a), property := (_ : WellFormed (Next C node a) ((fun a => ↑(k₁ a)) a)) }
{ val := ↑(k₂ a), property := (_ : WellFormed (Next C node a) ((fun x => ↑(k₂ x)) a)) } | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : B C node
⊢ ∃ h h_1,
R (Next C node a) { val := ↑(k₁ a), property := (_ : WellFormed (Next C node a) ((fun a => ↑(k₁ a)) a)) }
{ val := ↑(k₂ a), property := (_ : WellFormed (Next C node a) ((fun x => ↑(k₂ x)) a)) }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exists (by
rw [h₂] at wfy'
apply wfy'
) | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : B C node
⊢ ∃ h,
R (Next C node a) { val := ↑(k₁ a), property := (_ : WellFormed (Next C node a) ((fun a => ↑(k₁ a)) a)) }
{ val := ↑(k₂ a), property := (_ : WellFormed (Next C node a) ((fun x => ↑(k₂ x)) a)) } | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : B C node
⊢ R (Next C node a) { val := ↑(k₁ a), property := (_ : WellFormed (Next C node a) ((fun a => ↑(k₁ a)) a)) }
{ val := ↑(k₂ a), property := (_ : WellFormed (Next C node a) ((fun x => ↑(k₂ x)) a)) } | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : B C node
⊢ ∃ h,
R (Next C node a) { val := ↑(k₁ a), property := (_ : WellFormed (Next C node a) ((fun a => ↑(k₁ a)) a)) }
{ val := ↑(k₂ a), property := (_ : WellFormed (Next C node a) ((fun x => ↑(k₂ x)) a)) }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | exact h₃ a | case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : B C node
⊢ R (Next C node a) { val := ↑(k₁ a), property := (_ : WellFormed (Next C node a) ((fun a => ↑(k₁ a)) a)) }
{ val := ↑(k₂ a), property := (_ : WellFormed (Next C node a) ((fun x => ↑(k₂ x)) a)) } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h₀
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : B C node
⊢ R (Next C node a) { val := ↑(k₁ a), property := (_ : WellFormed (Next C node a) ((fun a => ↑(k₁ a)) a)) }
{ val := ↑(k₂ a), property := (_ : WellFormed (Next C node a) ((fun x => ↑(k₂ x)) a)) }
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | rw [h₁] at wfx' | I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : B C node
⊢ WellFormed (Next C node a) ↑(k₁ a) | I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀
(x :
B C
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }.fst),
WellFormed
(Next C
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }.fst
x)
(PSigma.snd
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
x)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : B C node
⊢ WellFormed (Next C node a) ↑(k₁ a) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : B C node
⊢ WellFormed (Next C node a) ↑(k₁ a)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | apply wfx' | I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀
(x :
B C
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }.fst),
WellFormed
(Next C
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }.fst
x)
(PSigma.snd
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
x)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : B C node
⊢ WellFormed (Next C node a) ↑(k₁ a) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀
(x :
B C
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }.fst),
WellFormed
(Next C
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }.fst
x)
(PSigma.snd
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
x)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : B C node
⊢ WellFormed (Next C node a) ↑(k₁ a)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | rw [h₂] at wfy' | I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : B C node
⊢ WellFormed (Next C node a) ↑(k₂ a) | I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀
(x :
B C
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }.fst),
WellFormed
(Next C
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }.fst
x)
(PSigma.snd
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
x)
a : B C node
⊢ WellFormed (Next C node a) ↑(k₂ a) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀ (x : B C (Container.M.destruct ↑{ val := y, property := wfy }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := y, property := wfy }).fst x)
(PSigma.snd (Container.M.destruct ↑{ val := y, property := wfy }) x)
a : B C node
⊢ WellFormed (Next C node a) ↑(k₂ a)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/Test.lean | IContainer'.M.bisim | [139, 1] | [176, 13] | apply wfy' | I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀
(x :
B C
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }.fst),
WellFormed
(Next C
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }.fst
x)
(PSigma.snd
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
x)
a : B C node
⊢ WellFormed (Next C node a) ↑(k₂ a) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer' I
R : (i : I) → M C i → M C i → Prop
h₀ :
∀ (i : I) (x y : M C i),
R i x y →
∃ node k₁ k₂,
destruct x = { fst := node, snd := k₁ } ∧
destruct y = { fst := node, snd := k₂ } ∧ ∀ (z : B C ↑node), R (Next C (↑node) z) (k₁ z) (k₂ z)
i✝ : I
x✝ : Container.M (toContainer C)
wfx✝ : WellFormed i✝ x✝
y✝ : Container.M (toContainer C)
wfy✝ : WellFormed i✝ y✝
h₁✝¹ : R i✝ { val := x✝, property := wfx✝ } { val := y✝, property := wfy✝ }
x y : Container.M (toContainer C)
i : I
wfx : WellFormed i x
wfy : WellFormed i y
r : R i { val := x, property := wfx } { val := y, property := wfy }
node : C.A
h₄ : i = Idx C node
k₁ k₂ : (y : B C ↑{ val := node, property := h₄ }) → M C (Next C (↑{ val := node, property := h₄ }) y)
h₁✝ : destruct { val := x, property := wfx } = { fst := { val := node, property := h₄ }, snd := k₁ }
h₂✝ : destruct { val := y, property := wfy } = { fst := { val := node, property := h₄ }, snd := k₂ }
h₃ : ∀ (z : B C ↑{ val := node, property := h₄ }), R (Next C (↑{ val := node, property := h₄ }) z) (k₁ z) (k₂ z)
h₁ :
Container.M.destruct x =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₁ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₁ } x) }
h₂ :
Container.M.destruct y =
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
wfx' :
∀ (x_1 : B C (Container.M.destruct ↑{ val := x, property := wfx }).fst),
WellFormed (Next C (Container.M.destruct ↑{ val := x, property := wfx }).fst x_1)
(PSigma.snd (Container.M.destruct ↑{ val := x, property := wfx }) x_1)
wfy' :
∀
(x :
B C
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }.fst),
WellFormed
(Next C
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }.fst
x)
(PSigma.snd
{ fst := ↑{ fst := { val := node, property := h₄ }, snd := k₂ }.fst,
snd := fun x => ↑(Sigma.snd { fst := { val := node, property := h₄ }, snd := k₂ } x) }
x)
a : B C node
⊢ WellFormed (Next C node a) ↑(k₂ a)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.wf_destruct | [50, 1] | [57, 10] | simp only [WellFormed, PWellFormed] at wf | I : Type u₀
C : IContainer I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : WellFormed i m
⊢ ∀
(x :
B C (Container.M.destruct ↑{ val := m, property := wf }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf }).fst.snd),
WellFormed
(N C (Container.M.destruct ↑{ val := m, property := wf }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf }).fst.snd x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf }) x) | I : Type u₀
C : IContainer I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : ↑(pgfp (WellFormedF C)) ⊥ i m
⊢ ∀
(x :
B C (Container.M.destruct ↑{ val := m, property := wf }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf }).fst.snd),
WellFormed
(N C (Container.M.destruct ↑{ val := m, property := wf }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf }).fst.snd x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf }) x) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : WellFormed i m
⊢ ∀
(x :
B C (Container.M.destruct ↑{ val := m, property := wf }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf }).fst.snd),
WellFormed
(N C (Container.M.destruct ↑{ val := m, property := wf }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf }).fst.snd x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf }) x)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.wf_destruct | [50, 1] | [57, 10] | rw [←pgfp.unfold] at wf | I : Type u₀
C : IContainer I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : ↑(pgfp (WellFormedF C)) ⊥ i m
⊢ ∀
(x :
B C (Container.M.destruct ↑{ val := m, property := wf }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf }).fst.snd),
WellFormed
(N C (Container.M.destruct ↑{ val := m, property := wf }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf }).fst.snd x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf }) x) | I : Type u₀
C : IContainer I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (⊥ ⊔ ↑(pgfp (WellFormedF C)) ⊥) i m
⊢ ∀
(x :
B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd),
WellFormed
(N C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : ↑(pgfp (WellFormedF C)) ⊥ i m
⊢ ∀
(x :
B C (Container.M.destruct ↑{ val := m, property := wf }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf }).fst.snd),
WellFormed
(N C (Container.M.destruct ↑{ val := m, property := wf }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf }).fst.snd x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf }) x)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.wf_destruct | [50, 1] | [57, 10] | simp only [CompleteLattice.bot_sup] at wf | I : Type u₀
C : IContainer I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (⊥ ⊔ ↑(pgfp (WellFormedF C)) ⊥) i m
⊢ ∀
(x :
B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd),
WellFormed
(N C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x) | I : Type u₀
C : IContainer I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
⊢ ∀
(x :
B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd),
WellFormed
(N C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (⊥ ⊔ ↑(pgfp (WellFormedF C)) ⊥) i m
⊢ ∀
(x :
B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd),
WellFormed
(N C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.wf_destruct | [50, 1] | [57, 10] | have ⟨_, y⟩ := wf | I : Type u₀
C : IContainer I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
⊢ ∀
(x :
B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd),
WellFormed
(N C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x) | I : Type u₀
C : IContainer I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
left✝ : (Container.M.destruct m).fst.fst = i
y :
∀ (x : B C (Container.M.destruct m).fst.fst (Container.M.destruct m).fst.snd),
↑(pgfp (WellFormedF C)) ⊥ (N C (Container.M.destruct m).fst.fst (Container.M.destruct m).fst.snd x)
(PSigma.snd (Container.M.destruct m) x)
⊢ ∀
(x :
B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd),
WellFormed
(N C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
⊢ ∀
(x :
B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd),
WellFormed
(N C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.wf_destruct | [50, 1] | [57, 10] | exact y | I : Type u₀
C : IContainer I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
left✝ : (Container.M.destruct m).fst.fst = i
y :
∀ (x : B C (Container.M.destruct m).fst.fst (Container.M.destruct m).fst.snd),
↑(pgfp (WellFormedF C)) ⊥ (N C (Container.M.destruct m).fst.fst (Container.M.destruct m).fst.snd x)
(PSigma.snd (Container.M.destruct m) x)
⊢ ∀
(x :
B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd),
WellFormed
(N C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf✝ : ↑(pgfp (WellFormedF C)) ⊥ i m
wf : ↑(WellFormedF C) (↑(pgfp (WellFormedF C)) ⊥) i m
left✝ : (Container.M.destruct m).fst.fst = i
y :
∀ (x : B C (Container.M.destruct m).fst.fst (Container.M.destruct m).fst.snd),
↑(pgfp (WellFormedF C)) ⊥ (N C (Container.M.destruct m).fst.fst (Container.M.destruct m).fst.snd x)
(PSigma.snd (Container.M.destruct m) x)
⊢ ∀
(x :
B C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd),
WellFormed
(N C (Container.M.destruct ↑{ val := m, property := wf✝ }).fst.fst
(Container.M.destruct ↑{ val := m, property := wf✝ }).fst.snd x)
(PSigma.snd (Container.M.destruct ↑{ val := m, property := wf✝ }) x)
TACTIC:
|
https://github.com/RemyCiterin/LeanCoInd.git | 69d305ae769624f460f9c1ee6a0351917f4b74cf | CoInd/MIdx.lean | IContainer.M.index_destruct | [59, 1] | [66, 10] | simp only [WellFormed, PWellFormed] at wf | I : Type u₀
C : IContainer I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : WellFormed i m
⊢ i = (Container.M.destruct ↑{ val := m, property := wf }).fst.fst | I : Type u₀
C : IContainer I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : ↑(pgfp (WellFormedF C)) ⊥ i m
⊢ i = (Container.M.destruct ↑{ val := m, property := wf }).fst.fst | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u₀
C : IContainer I
i : I
x✝ : M C i
m : Container.M (toContainer C)
wf : WellFormed i m
⊢ i = (Container.M.destruct ↑{ val := m, property := wf }).fst.fst
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.