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/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Int/Lemmas.lean | Int.mk_mul_mk | [136, 1] | [141, 176] | simp only [Nat.mul_succ, Nat.succ_mul] | case succ_succ
m₁ n₁ m₂ n₂ : Nat
ih : (m₁ ⊖ n₁) * (m₂ ⊖ n₂) = m₁ * m₂ + n₁ * n₂ ⊖ m₁ * n₂ + n₁ * m₂
⊢ (m₁ ⊖ n₁) * (m₂ + 1 ⊖ n₂ + 1) = m₁ * (m₂ + 1) + n₁ * (n₂ + 1) ⊖ m₁ * (n₂ + 1) + n₁ * (m₂ + 1) | case succ_succ
m₁ n₁ m₂ n₂ : Nat
ih : (m₁ ⊖ n₁) * (m₂ ⊖ n₂) = m₁ * m₂ + n₁ * n₂ ⊖ m₁ * n₂ + n₁ * m₂
⊢ (m₁ ⊖ n₁) * (m₂ + 1 ⊖ n₂ + 1) = m₁ * m₂ + m₁ + (n₁ * n₂ + n₁) ⊖ m₁ * n₂ + m₁ + (n₁ * m₂ + n₁) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ_succ
m₁ n₁ m₂ n₂ : Nat
ih : (m₁ ⊖ n₁) * (m₂ ⊖ n₂) = m₁ * m₂ + n₁ * n₂ ⊖ m₁ * n₂ + n₁ * m₂
⊢ (m₁ ⊖ n₁) * (m₂ + 1 ⊖ n₂ + 1) = m₁ * (m₂ + 1) + n₁ * (n₂ + 1) ⊖ m₁ * (n₂ + 1) + n₁ * (m₂ + 1)
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Int/Lemmas.lean | Int.mk_mul_mk | [136, 1] | [141, 176] | rw [succ_mk_succ, Nat.add_add_add_comm _ m₁ _ n₁, Nat.add_add_add_comm _ m₁ _ n₁, add_mk_add_right] | case succ_succ
m₁ n₁ m₂ n₂ : Nat
ih : (m₁ ⊖ n₁) * (m₂ ⊖ n₂) = m₁ * m₂ + n₁ * n₂ ⊖ m₁ * n₂ + n₁ * m₂
⊢ (m₁ ⊖ n₁) * (m₂ + 1 ⊖ n₂ + 1) = m₁ * m₂ + m₁ + (n₁ * n₂ + n₁) ⊖ m₁ * n₂ + m₁ + (n₁ * m₂ + n₁) | case succ_succ
m₁ n₁ m₂ n₂ : Nat
ih : (m₁ ⊖ n₁) * (m₂ ⊖ n₂) = m₁ * m₂ + n₁ * n₂ ⊖ m₁ * n₂ + n₁ * m₂
⊢ (m₁ ⊖ n₁) * (m₂ ⊖ n₂) = m₁ * m₂ + n₁ * n₂ ⊖ m₁ * n₂ + n₁ * m₂ | Please generate a tactic in lean4 to solve the state.
STATE:
case succ_succ
m₁ n₁ m₂ n₂ : Nat
ih : (m₁ ⊖ n₁) * (m₂ ⊖ n₂) = m₁ * m₂ + n₁ * n₂ ⊖ m₁ * n₂ + n₁ * m₂
⊢ (m₁ ⊖ n₁) * (m₂ + 1 ⊖ n₂ + 1) = m₁ * m₂ + m₁ + (n₁ * n₂ + n₁) ⊖ m₁ * n₂ + m₁ + (n₁ * m₂ + n₁)
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Int/Lemmas.lean | Int.mk_mul_mk | [136, 1] | [141, 176] | exact ih | case succ_succ
m₁ n₁ m₂ n₂ : Nat
ih : (m₁ ⊖ n₁) * (m₂ ⊖ n₂) = m₁ * m₂ + n₁ * n₂ ⊖ m₁ * n₂ + n₁ * m₂
⊢ (m₁ ⊖ n₁) * (m₂ ⊖ n₂) = m₁ * m₂ + n₁ * n₂ ⊖ m₁ * n₂ + n₁ * m₂ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ_succ
m₁ n₁ m₂ n₂ : Nat
ih : (m₁ ⊖ n₁) * (m₂ ⊖ n₂) = m₁ * m₂ + n₁ * n₂ ⊖ m₁ * n₂ + n₁ * m₂
⊢ (m₁ ⊖ n₁) * (m₂ ⊖ n₂) = m₁ * m₂ + n₁ * n₂ ⊖ m₁ * n₂ + n₁ * m₂
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Cast/DCast.lean | congr_ndrec | [9, 1] | [10, 51] | cases h | α : Sort u_1
γ : Sort u_2
x x' : α
β : α → Sort u_3
f : (x : α) → β x → γ
h : x = x'
y : β x
⊢ f x' (h ▸ y) = f x y | case refl
α : Sort u_1
γ : Sort u_2
x : α
β : α → Sort u_3
f : (x : α) → β x → γ
y : β x
⊢ f x (⋯ ▸ y) = f x y | Please generate a tactic in lean4 to solve the state.
STATE:
α : Sort u_1
γ : Sort u_2
x x' : α
β : α → Sort u_3
f : (x : α) → β x → γ
h : x = x'
y : β x
⊢ f x' (h ▸ y) = f x y
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Cast/DCast.lean | congr_ndrec | [9, 1] | [10, 51] | rfl | case refl
α : Sort u_1
γ : Sort u_2
x : α
β : α → Sort u_3
f : (x : α) → β x → γ
y : β x
⊢ f x (⋯ ▸ y) = f x y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
α : Sort u_1
γ : Sort u_2
x : α
β : α → Sort u_3
f : (x : α) → β x → γ
y : β x
⊢ f x (⋯ ▸ y) = f x y
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Cast/DCast.lean | dcast_id | [27, 1] | [27, 101] | cases h | α : Sort u_1
a : α
motive : α → Sort u_2
h : a = a
t : motive a
⊢ dcast h t = t | case refl
α : Sort u_1
a : α
motive : α → Sort u_2
t : motive a
⊢ dcast ⋯ t = t | Please generate a tactic in lean4 to solve the state.
STATE:
α : Sort u_1
a : α
motive : α → Sort u_2
h : a = a
t : motive a
⊢ dcast h t = t
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Cast/DCast.lean | dcast_id | [27, 1] | [27, 101] | rfl | case refl
α : Sort u_1
a : α
motive : α → Sort u_2
t : motive a
⊢ dcast ⋯ t = t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
α : Sort u_1
a : α
motive : α → Sort u_2
t : motive a
⊢ dcast ⋯ t = t
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Cast/DCast.lean | dcast_comp | [30, 1] | [31, 78] | cases hab | α : Sort u_1
a b c : α
motive : α → Sort u_2
hab : a = b
hbc : b = c
t : motive a
⊢ dcast hbc (dcast hab t) = dcast ⋯ t | case refl
α : Sort u_1
a c : α
motive : α → Sort u_2
t : motive a
hbc : a = c
⊢ dcast hbc (dcast ⋯ t) = dcast ⋯ t | Please generate a tactic in lean4 to solve the state.
STATE:
α : Sort u_1
a b c : α
motive : α → Sort u_2
hab : a = b
hbc : b = c
t : motive a
⊢ dcast hbc (dcast hab t) = dcast ⋯ t
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Cast/DCast.lean | dcast_comp | [30, 1] | [31, 78] | rfl | case refl
α : Sort u_1
a c : α
motive : α → Sort u_2
t : motive a
hbc : a = c
⊢ dcast hbc (dcast ⋯ t) = dcast ⋯ t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
α : Sort u_1
a c : α
motive : α → Sort u_2
t : motive a
hbc : a = c
⊢ dcast hbc (dcast ⋯ t) = dcast ⋯ t
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Cast/DCast.lean | deq_dcast_left | [34, 1] | [35, 51] | cases h | α : Sort u_1
a b c : α
motive : α → Sort u_2
h : a = b
t : motive a
u : motive c
⊢ DEq (dcast h t) u ↔ DEq t u | case refl
α : Sort u_1
a c : α
motive : α → Sort u_2
t : motive a
u : motive c
⊢ DEq (dcast ⋯ t) u ↔ DEq t u | Please generate a tactic in lean4 to solve the state.
STATE:
α : Sort u_1
a b c : α
motive : α → Sort u_2
h : a = b
t : motive a
u : motive c
⊢ DEq (dcast h t) u ↔ DEq t u
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Cast/DCast.lean | deq_dcast_left | [34, 1] | [35, 51] | rfl | case refl
α : Sort u_1
a c : α
motive : α → Sort u_2
t : motive a
u : motive c
⊢ DEq (dcast ⋯ t) u ↔ DEq t u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
α : Sort u_1
a c : α
motive : α → Sort u_2
t : motive a
u : motive c
⊢ DEq (dcast ⋯ t) u ↔ DEq t u
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Cast/DCast.lean | deq_dcast_right | [38, 1] | [39, 51] | cases h | α : Sort u_1
b c a : α
motive : α → Sort u_2
h : b = c
t : motive a
u : motive b
⊢ DEq t (dcast h u) ↔ DEq t u | case refl
α : Sort u_1
b a : α
motive : α → Sort u_2
t : motive a
u : motive b
⊢ DEq t (dcast ⋯ u) ↔ DEq t u | Please generate a tactic in lean4 to solve the state.
STATE:
α : Sort u_1
b c a : α
motive : α → Sort u_2
h : b = c
t : motive a
u : motive b
⊢ DEq t (dcast h u) ↔ DEq t u
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Cast/DCast.lean | deq_dcast_right | [38, 1] | [39, 51] | rfl | case refl
α : Sort u_1
b a : α
motive : α → Sort u_2
t : motive a
u : motive b
⊢ DEq t (dcast ⋯ u) ↔ DEq t u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
α : Sort u_1
b a : α
motive : α → Sort u_2
t : motive a
u : motive b
⊢ DEq t (dcast ⋯ u) ↔ DEq t u
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Cast/DCast.lean | heq_dcast_left | [42, 1] | [43, 51] | cases h | α : Sort u_1
a b c : α
motive : α → Sort u_2
h : a = b
t : motive a
u : motive c
⊢ HEq (dcast h t) u ↔ HEq t u | case refl
α : Sort u_1
a c : α
motive : α → Sort u_2
t : motive a
u : motive c
⊢ HEq (dcast ⋯ t) u ↔ HEq t u | Please generate a tactic in lean4 to solve the state.
STATE:
α : Sort u_1
a b c : α
motive : α → Sort u_2
h : a = b
t : motive a
u : motive c
⊢ HEq (dcast h t) u ↔ HEq t u
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Cast/DCast.lean | heq_dcast_left | [42, 1] | [43, 51] | rfl | case refl
α : Sort u_1
a c : α
motive : α → Sort u_2
t : motive a
u : motive c
⊢ HEq (dcast ⋯ t) u ↔ HEq t u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
α : Sort u_1
a c : α
motive : α → Sort u_2
t : motive a
u : motive c
⊢ HEq (dcast ⋯ t) u ↔ HEq t u
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Cast/DCast.lean | heq_dcast_right | [46, 1] | [47, 51] | cases h | α : Sort u_1
b c a : α
motive : α → Sort u_2
h : b = c
t : motive a
u : motive b
⊢ HEq t (dcast h u) ↔ HEq t u | case refl
α : Sort u_1
b a : α
motive : α → Sort u_2
t : motive a
u : motive b
⊢ HEq t (dcast ⋯ u) ↔ HEq t u | Please generate a tactic in lean4 to solve the state.
STATE:
α : Sort u_1
b c a : α
motive : α → Sort u_2
h : b = c
t : motive a
u : motive b
⊢ HEq t (dcast h u) ↔ HEq t u
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Cast/DCast.lean | heq_dcast_right | [46, 1] | [47, 51] | rfl | case refl
α : Sort u_1
b a : α
motive : α → Sort u_2
t : motive a
u : motive b
⊢ HEq t (dcast ⋯ u) ↔ HEq t u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
α : Sort u_1
b a : α
motive : α → Sort u_2
t : motive a
u : motive b
⊢ HEq t (dcast ⋯ u) ↔ HEq t u
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.unappend_append | [27, 1] | [37, 49] | induction xs generalizing ys with
| nil =>
match i with
| .inl i => contradiction
| .inr j => rfl
| cons x xs ih =>
match i with
| .inl .head => rfl
| .inl (.tail i) => simp only [append, unappend, ih]
| .inr j => simp only [append, unappend, ih] | α✝ : Type u_1
xs ys : List α✝
i : xs.Index ⊕ ys.Index
⊢ (append i).unappend = i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
xs ys : List α✝
i : xs.Index ⊕ ys.Index
⊢ (append i).unappend = i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.unappend_append | [27, 1] | [37, 49] | match i with
| .inl i => contradiction
| .inr j => rfl | case nil
α✝ : Type u_1
ys : List α✝
i : [].Index ⊕ ys.Index
⊢ (append i).unappend = i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α✝ : Type u_1
ys : List α✝
i : [].Index ⊕ ys.Index
⊢ (append i).unappend = i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.unappend_append | [27, 1] | [37, 49] | contradiction | α✝ : Type u_1
ys : List α✝
i✝ : [].Index ⊕ ys.Index
i : [].Index
⊢ (append (Sum.inl i)).unappend = Sum.inl i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
ys : List α✝
i✝ : [].Index ⊕ ys.Index
i : [].Index
⊢ (append (Sum.inl i)).unappend = Sum.inl i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.unappend_append | [27, 1] | [37, 49] | rfl | α✝ : Type u_1
ys : List α✝
i : [].Index ⊕ ys.Index
j : ys.Index
⊢ (append (Sum.inr j)).unappend = Sum.inr j | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
ys : List α✝
i : [].Index ⊕ ys.Index
j : ys.Index
⊢ (append (Sum.inr j)).unappend = Sum.inr j
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.unappend_append | [27, 1] | [37, 49] | match i with
| .inl .head => rfl
| .inl (.tail i) => simp only [append, unappend, ih]
| .inr j => simp only [append, unappend, ih] | case cons
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (i : xs.Index ⊕ ys.Index), (append i).unappend = i
ys : List α✝
i : (x :: xs).Index ⊕ ys.Index
⊢ (append i).unappend = i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (i : xs.Index ⊕ ys.Index), (append i).unappend = i
ys : List α✝
i : (x :: xs).Index ⊕ ys.Index
⊢ (append i).unappend = i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.unappend_append | [27, 1] | [37, 49] | rfl | α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (i : xs.Index ⊕ ys.Index), (append i).unappend = i
ys : List α✝
i : (x :: xs).Index ⊕ ys.Index
⊢ (append (Sum.inl head)).unappend = Sum.inl head | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (i : xs.Index ⊕ ys.Index), (append i).unappend = i
ys : List α✝
i : (x :: xs).Index ⊕ ys.Index
⊢ (append (Sum.inl head)).unappend = Sum.inl head
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.unappend_append | [27, 1] | [37, 49] | simp only [append, unappend, ih] | α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (i : xs.Index ⊕ ys.Index), (append i).unappend = i
ys : List α✝
i✝ : (x :: xs).Index ⊕ ys.Index
i : xs.Index
⊢ (append (Sum.inl i.tail)).unappend = Sum.inl i.tail | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (i : xs.Index ⊕ ys.Index), (append i).unappend = i
ys : List α✝
i✝ : (x :: xs).Index ⊕ ys.Index
i : xs.Index
⊢ (append (Sum.inl i.tail)).unappend = Sum.inl i.tail
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.unappend_append | [27, 1] | [37, 49] | simp only [append, unappend, ih] | α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (i : xs.Index ⊕ ys.Index), (append i).unappend = i
ys : List α✝
i : (x :: xs).Index ⊕ ys.Index
j : ys.Index
⊢ (append (Sum.inr j)).unappend = Sum.inr j | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (i : xs.Index ⊕ ys.Index), (append i).unappend = i
ys : List α✝
i : (x :: xs).Index ⊕ ys.Index
j : ys.Index
⊢ (append (Sum.inr j)).unappend = Sum.inr j
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.append_unappend | [39, 1] | [49, 36] | induction xs generalizing ys with
| nil => rfl
| cons x xs ih =>
match k with
| .head => rfl
| .tail k =>
simp only [unappend]
split
next h => rw [append, ←h, ih]
next h => rw [append, ←h, ih] | α✝ : Type u_1
xs ys : List α✝
k : (xs ++ ys).Index
⊢ append k.unappend = k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
xs ys : List α✝
k : (xs ++ ys).Index
⊢ append k.unappend = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.append_unappend | [39, 1] | [49, 36] | rfl | case nil
α✝ : Type u_1
ys : List α✝
k : ([] ++ ys).Index
⊢ append k.unappend = k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α✝ : Type u_1
ys : List α✝
k : ([] ++ ys).Index
⊢ append k.unappend = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.append_unappend | [39, 1] | [49, 36] | match k with
| .head => rfl
| .tail k =>
simp only [unappend]
split
next h => rw [append, ←h, ih]
next h => rw [append, ←h, ih] | case cons
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k : (x :: xs ++ ys).Index
⊢ append k.unappend = k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k : (x :: xs ++ ys).Index
⊢ append k.unappend = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.append_unappend | [39, 1] | [49, 36] | rfl | α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k : (x :: xs ++ ys).Index
⊢ append head.unappend = head | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k : (x :: xs ++ ys).Index
⊢ append head.unappend = head
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.append_unappend | [39, 1] | [49, 36] | simp only [unappend] | α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k✝ : (x :: xs ++ ys).Index
k : (xs.append ys).Index
⊢ append k.tail.unappend = k.tail | α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k✝ : (x :: xs ++ ys).Index
k : (xs.append ys).Index
⊢ append
(match k.unappend with
| Sum.inl i => Sum.inl i.tail
| Sum.inr i => Sum.inr i) =
k.tail | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k✝ : (x :: xs ++ ys).Index
k : (xs.append ys).Index
⊢ append k.tail.unappend = k.tail
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.append_unappend | [39, 1] | [49, 36] | split | α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k✝ : (x :: xs ++ ys).Index
k : (xs.append ys).Index
⊢ append
(match k.unappend with
| Sum.inl i => Sum.inl i.tail
| Sum.inr i => Sum.inr i) =
k.tail | case h_1
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k✝ : (x :: xs ++ ys).Index
k : (xs.append ys).Index
x✝ : xs.Index ⊕ ys.Index
i✝ : xs.Index
heq✝ : k.unappend = Sum.inl i✝
⊢ append (Sum.inl i✝.tail) = k.tail
case h_2
α✝ : Type u_1
x : α✝
xs : Li... | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k✝ : (x :: xs ++ ys).Index
k : (xs.append ys).Index
⊢ append
(match k.unappend with
| Sum.inl i => Sum.inl i.tail
| Sum.inr i ... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.append_unappend | [39, 1] | [49, 36] | next h => rw [append, ←h, ih] | case h_1
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k✝ : (x :: xs ++ ys).Index
k : (xs.append ys).Index
x✝ : xs.Index ⊕ ys.Index
i✝ : xs.Index
heq✝ : k.unappend = Sum.inl i✝
⊢ append (Sum.inl i✝.tail) = k.tail
case h_2
α✝ : Type u_1
x : α✝
xs : Li... | case h_2
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k✝ : (x :: xs ++ ys).Index
k : (xs.append ys).Index
x✝ : xs.Index ⊕ ys.Index
i✝ : ys.Index
heq✝ : k.unappend = Sum.inr i✝
⊢ append (Sum.inr i✝) = k.tail | Please generate a tactic in lean4 to solve the state.
STATE:
case h_1
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k✝ : (x :: xs ++ ys).Index
k : (xs.append ys).Index
x✝ : xs.Index ⊕ ys.Index
i✝ : xs.Index
heq✝ : k.unappend = Sum.inl i✝
⊢ append (Sum... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.append_unappend | [39, 1] | [49, 36] | next h => rw [append, ←h, ih] | case h_2
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k✝ : (x :: xs ++ ys).Index
k : (xs.append ys).Index
x✝ : xs.Index ⊕ ys.Index
i✝ : ys.Index
heq✝ : k.unappend = Sum.inr i✝
⊢ append (Sum.inr i✝) = k.tail | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k✝ : (x :: xs ++ ys).Index
k : (xs.append ys).Index
x✝ : xs.Index ⊕ ys.Index
i✝ : ys.Index
heq✝ : k.unappend = Sum.inr i✝
⊢ append (Sum... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.append_unappend | [39, 1] | [49, 36] | rw [append, ←h, ih] | α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k✝ : (x :: xs ++ ys).Index
k : (xs.append ys).Index
x✝ : xs.Index ⊕ ys.Index
i✝ : xs.Index
h : k.unappend = Sum.inl i✝
⊢ append (Sum.inl i✝.tail) = k.tail | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k✝ : (x :: xs ++ ys).Index
k : (xs.append ys).Index
x✝ : xs.Index ⊕ ys.Index
i✝ : xs.Index
h : k.unappend = Sum.inl i✝
⊢ append (Sum.inl i✝.tail... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.append_unappend | [39, 1] | [49, 36] | rw [append, ←h, ih] | α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k✝ : (x :: xs ++ ys).Index
k : (xs.append ys).Index
x✝ : xs.Index ⊕ ys.Index
i✝ : ys.Index
h : k.unappend = Sum.inr i✝
⊢ append (Sum.inr i✝) = k.tail | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {ys : List α✝} (k : (xs ++ ys).Index), append k.unappend = k
ys : List α✝
k✝ : (x :: xs ++ ys).Index
k : (xs.append ys).Index
x✝ : xs.Index ⊕ ys.Index
i✝ : ys.Index
h : k.unappend = Sum.inr i✝
⊢ append (Sum.inr i✝) = k... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.append_eq_iff_eq_unappend | [51, 1] | [54, 37] | constructor | α✝ : Type u_1
xs ys : List α✝
i : xs.Index ⊕ ys.Index
j : (xs ++ ys).Index
⊢ append i = j ↔ i = j.unappend | case mp
α✝ : Type u_1
xs ys : List α✝
i : xs.Index ⊕ ys.Index
j : (xs ++ ys).Index
⊢ append i = j → i = j.unappend
case mpr
α✝ : Type u_1
xs ys : List α✝
i : xs.Index ⊕ ys.Index
j : (xs ++ ys).Index
⊢ i = j.unappend → append i = j | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
xs ys : List α✝
i : xs.Index ⊕ ys.Index
j : (xs ++ ys).Index
⊢ append i = j ↔ i = j.unappend
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.append_eq_iff_eq_unappend | [51, 1] | [54, 37] | intro h | case mp
α✝ : Type u_1
xs ys : List α✝
i : xs.Index ⊕ ys.Index
j : (xs ++ ys).Index
⊢ append i = j → i = j.unappend | case mp
α✝ : Type u_1
xs ys : List α✝
i : xs.Index ⊕ ys.Index
j : (xs ++ ys).Index
h : append i = j
⊢ i = j.unappend | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α✝ : Type u_1
xs ys : List α✝
i : xs.Index ⊕ ys.Index
j : (xs ++ ys).Index
⊢ append i = j → i = j.unappend
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.append_eq_iff_eq_unappend | [51, 1] | [54, 37] | rw [←h, unappend_append] | case mp
α✝ : Type u_1
xs ys : List α✝
i : xs.Index ⊕ ys.Index
j : (xs ++ ys).Index
h : append i = j
⊢ i = j.unappend | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α✝ : Type u_1
xs ys : List α✝
i : xs.Index ⊕ ys.Index
j : (xs ++ ys).Index
h : append i = j
⊢ i = j.unappend
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.append_eq_iff_eq_unappend | [51, 1] | [54, 37] | intro h | case mpr
α✝ : Type u_1
xs ys : List α✝
i : xs.Index ⊕ ys.Index
j : (xs ++ ys).Index
⊢ i = j.unappend → append i = j | case mpr
α✝ : Type u_1
xs ys : List α✝
i : xs.Index ⊕ ys.Index
j : (xs ++ ys).Index
h : i = j.unappend
⊢ append i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α✝ : Type u_1
xs ys : List α✝
i : xs.Index ⊕ ys.Index
j : (xs ++ ys).Index
⊢ i = j.unappend → append i = j
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.append_eq_iff_eq_unappend | [51, 1] | [54, 37] | rw [h, append_unappend] | case mpr
α✝ : Type u_1
xs ys : List α✝
i : xs.Index ⊕ ys.Index
j : (xs ++ ys).Index
h : i = j.unappend
⊢ append i = j | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α✝ : Type u_1
xs ys : List α✝
i : xs.Index ⊕ ys.Index
j : (xs ++ ys).Index
h : i = j.unappend
⊢ append i = j
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.unappend_eq_iff_eq_append | [56, 1] | [59, 37] | constructor | α✝ : Type u_1
xs ys : List α✝
i : (xs ++ ys).Index
j : xs.Index ⊕ ys.Index
⊢ i.unappend = j ↔ i = append j | case mp
α✝ : Type u_1
xs ys : List α✝
i : (xs ++ ys).Index
j : xs.Index ⊕ ys.Index
⊢ i.unappend = j → i = append j
case mpr
α✝ : Type u_1
xs ys : List α✝
i : (xs ++ ys).Index
j : xs.Index ⊕ ys.Index
⊢ i = append j → i.unappend = j | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
xs ys : List α✝
i : (xs ++ ys).Index
j : xs.Index ⊕ ys.Index
⊢ i.unappend = j ↔ i = append j
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.unappend_eq_iff_eq_append | [56, 1] | [59, 37] | intro h | case mp
α✝ : Type u_1
xs ys : List α✝
i : (xs ++ ys).Index
j : xs.Index ⊕ ys.Index
⊢ i.unappend = j → i = append j | case mp
α✝ : Type u_1
xs ys : List α✝
i : (xs ++ ys).Index
j : xs.Index ⊕ ys.Index
h : i.unappend = j
⊢ i = append j | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α✝ : Type u_1
xs ys : List α✝
i : (xs ++ ys).Index
j : xs.Index ⊕ ys.Index
⊢ i.unappend = j → i = append j
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.unappend_eq_iff_eq_append | [56, 1] | [59, 37] | rw [←h, append_unappend] | case mp
α✝ : Type u_1
xs ys : List α✝
i : (xs ++ ys).Index
j : xs.Index ⊕ ys.Index
h : i.unappend = j
⊢ i = append j | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α✝ : Type u_1
xs ys : List α✝
i : (xs ++ ys).Index
j : xs.Index ⊕ ys.Index
h : i.unappend = j
⊢ i = append j
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.unappend_eq_iff_eq_append | [56, 1] | [59, 37] | intro h | case mpr
α✝ : Type u_1
xs ys : List α✝
i : (xs ++ ys).Index
j : xs.Index ⊕ ys.Index
⊢ i = append j → i.unappend = j | case mpr
α✝ : Type u_1
xs ys : List α✝
i : (xs ++ ys).Index
j : xs.Index ⊕ ys.Index
h : i = append j
⊢ i.unappend = j | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α✝ : Type u_1
xs ys : List α✝
i : (xs ++ ys).Index
j : xs.Index ⊕ ys.Index
⊢ i = append j → i.unappend = j
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.unappend_eq_iff_eq_append | [56, 1] | [59, 37] | rw [h, unappend_append] | case mpr
α✝ : Type u_1
xs ys : List α✝
i : (xs ++ ys).Index
j : xs.Index ⊕ ys.Index
h : i = append j
⊢ i.unappend = j | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α✝ : Type u_1
xs ys : List α✝
i : (xs ++ ys).Index
j : xs.Index ⊕ ys.Index
h : i = append j
⊢ i.unappend = j
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.val_append_inl | [70, 1] | [73, 26] | induction i with
| head => rfl
| tail _ ih => exact ih | α✝ : Type u_1
xs ys : List α✝
i : xs.Index
⊢ i.append_inl.val = i.val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
xs ys : List α✝
i : xs.Index
⊢ i.append_inl.val = i.val
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.val_append_inl | [70, 1] | [73, 26] | rfl | case head
α✝ : Type u_1
xs ys : List α✝
x✝ : α✝
xs✝ : List α✝
⊢ head.append_inl.val = head.val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case head
α✝ : Type u_1
xs ys : List α✝
x✝ : α✝
xs✝ : List α✝
⊢ head.append_inl.val = head.val
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.val_append_inl | [70, 1] | [73, 26] | exact ih | case tail
α✝ : Type u_1
xs ys xs✝ : List α✝
x✝ : α✝
a✝ : xs✝.Index
ih : a✝.append_inl.val = a✝.val
⊢ a✝.tail.append_inl.val = a✝.tail.val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case tail
α✝ : Type u_1
xs ys xs✝ : List α✝
x✝ : α✝
a✝ : xs✝.Index
ih : a✝.append_inl.val = a✝.val
⊢ a✝.tail.append_inl.val = a✝.tail.val
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.val_append_inr | [75, 1] | [78, 28] | induction xs with
| nil => rfl
| cons _ _ ih => exact ih | α✝ : Type u_1
ys xs : List α✝
j : ys.Index
⊢ j.append_inr.val = j.val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
ys xs : List α✝
j : ys.Index
⊢ j.append_inr.val = j.val
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.val_append_inr | [75, 1] | [78, 28] | rfl | case nil
α✝ : Type u_1
ys : List α✝
j : ys.Index
⊢ j.append_inr.val = j.val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α✝ : Type u_1
ys : List α✝
j : ys.Index
⊢ j.append_inr.val = j.val
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.val_append_inr | [75, 1] | [78, 28] | exact ih | case cons
α✝ : Type u_1
ys : List α✝
j : ys.Index
head✝ : α✝
tail✝ : List α✝
ih : j.append_inr.val = j.val
⊢ j.append_inr.val = j.val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α✝ : Type u_1
ys : List α✝
j : ys.Index
head✝ : α✝
tail✝ : List α✝
ih : j.append_inr.val = j.val
⊢ j.append_inr.val = j.val
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.val_append | [80, 1] | [83, 38] | match i with
| .inl _ => exact val_append_inl ..
| .inr _ => exact val_append_inr .. | α : Type u_1
xs ys : List α
i : xs.Index ⊕ ys.Index
⊢ (append i).val =
match i with
| Sum.inl i => i.val
| Sum.inr j => j.val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs ys : List α
i : xs.Index ⊕ ys.Index
⊢ (append i).val =
match i with
| Sum.inl i => i.val
| Sum.inr j => j.val
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.val_append | [80, 1] | [83, 38] | exact val_append_inl .. | α : Type u_1
xs ys : List α
i : xs.Index ⊕ ys.Index
val✝ : xs.Index
⊢ (append (Sum.inl val✝)).val =
match Sum.inl val✝ with
| Sum.inl i => i.val
| Sum.inr j => j.val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs ys : List α
i : xs.Index ⊕ ys.Index
val✝ : xs.Index
⊢ (append (Sum.inl val✝)).val =
match Sum.inl val✝ with
| Sum.inl i => i.val
| Sum.inr j => j.val
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.val_append | [80, 1] | [83, 38] | exact val_append_inr .. | α : Type u_1
xs ys : List α
i : xs.Index ⊕ ys.Index
val✝ : ys.Index
⊢ (append (Sum.inr val✝)).val =
match Sum.inr val✝ with
| Sum.inl i => i.val
| Sum.inr j => j.val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs ys : List α
i : xs.Index ⊕ ys.Index
val✝ : ys.Index
⊢ (append (Sum.inr val✝)).val =
match Sum.inr val✝ with
| Sum.inl i => i.val
| Sum.inr j => j.val
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Append.lean | List.Index.val_unappend | [85, 1] | [86, 55] | rw [←append_unappend k, val_append, unappend_append] | α : Type u_1
xs ys : List α
k : (xs ++ ys).Index
⊢ (match k.unappend with
| Sum.inl i => i.val
| Sum.inr j => j.val) =
k.val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs ys : List α
k : (xs ++ ys).Index
⊢ (match k.unappend with
| Sum.inl i => i.val
| Sum.inr j => j.val) =
k.val
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.unsum_sum | [20, 1] | [22, 68] | simp only [unsum, sum, unappend_append, unmap_map] | α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
val✝ : xs.Index
⊢ (sum (Sum.inl val✝)).unsum = Sum.inl val✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
val✝ : xs.Index
⊢ (sum (Sum.inl val✝)).unsum = Sum.inl val✝
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.unsum_sum | [20, 1] | [22, 68] | simp only [unsum, sum, unappend_append, unmap_map] | α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
val✝ : ys.Index
⊢ (sum (Sum.inr val✝)).unsum = Sum.inr val✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
val✝ : ys.Index
⊢ (sum (Sum.inr val✝)).unsum = Sum.inr val✝
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.sum_unsum | [24, 1] | [27, 105] | match h : unappend k with
| .inl i => rw [unappend_eq_iff_eq_append] at h; simp only [h, unsum, unappend_append, sum, map_unmap]
| .inr j => rw [unappend_eq_iff_eq_append] at h; simp only [h, unsum, unappend_append, sum, map_unmap] | α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
⊢ sum k.unsum = k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
⊢ sum k.unsum = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.sum_unsum | [24, 1] | [27, 105] | rw [unappend_eq_iff_eq_append] at h | α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : (List.map Sum.inl xs).Index
h : k.unappend = Sum.inl i
⊢ sum k.unsum = k | α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : (List.map Sum.inl xs).Index
h : k = append (Sum.inl i)
⊢ sum k.unsum = k | Please generate a tactic in lean4 to solve the state.
STATE:
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : (List.map Sum.inl xs).Index
h : k.unappend = Sum.inl i
⊢ sum k.unsum = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.sum_unsum | [24, 1] | [27, 105] | simp only [h, unsum, unappend_append, sum, map_unmap] | α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : (List.map Sum.inl xs).Index
h : k = append (Sum.inl i)
⊢ sum k.unsum = k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : (List.map Sum.inl xs).Index
h : k = append (Sum.inl i)
⊢ sum k.unsum = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.sum_unsum | [24, 1] | [27, 105] | rw [unappend_eq_iff_eq_append] at h | α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
j : (List.map Sum.inr ys).Index
h : k.unappend = Sum.inr j
⊢ sum k.unsum = k | α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
j : (List.map Sum.inr ys).Index
h : k = append (Sum.inr j)
⊢ sum k.unsum = k | Please generate a tactic in lean4 to solve the state.
STATE:
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
j : (List.map Sum.inr ys).Index
h : k.unappend = Sum.inr j
⊢ sum k.unsum = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.sum_unsum | [24, 1] | [27, 105] | simp only [h, unsum, unappend_append, sum, map_unmap] | α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
j : (List.map Sum.inr ys).Index
h : k = append (Sum.inr j)
⊢ sum k.unsum = k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
j : (List.map Sum.inr ys).Index
h : k = append (Sum.inr j)
⊢ sum k.unsum = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.sum_eq_iff_eq_unsum | [29, 1] | [32, 31] | constructor | α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
i : xs.Index ⊕ ys.Index
k : (xs.sum ys).Index
⊢ sum i = k ↔ i = k.unsum | case mp
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
i : xs.Index ⊕ ys.Index
k : (xs.sum ys).Index
⊢ sum i = k → i = k.unsum
case mpr
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
i : xs.Index ⊕ ys.Index
k : (xs.sum ys).Index
⊢ i = k.unsum → sum i = k | Please generate a tactic in lean4 to solve the state.
STATE:
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
i : xs.Index ⊕ ys.Index
k : (xs.sum ys).Index
⊢ sum i = k ↔ i = k.unsum
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.sum_eq_iff_eq_unsum | [29, 1] | [32, 31] | intro h | case mp
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
i : xs.Index ⊕ ys.Index
k : (xs.sum ys).Index
⊢ sum i = k → i = k.unsum | case mp
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
i : xs.Index ⊕ ys.Index
k : (xs.sum ys).Index
h : sum i = k
⊢ i = k.unsum | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
i : xs.Index ⊕ ys.Index
k : (xs.sum ys).Index
⊢ sum i = k → i = k.unsum
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.sum_eq_iff_eq_unsum | [29, 1] | [32, 31] | rw [←h, unsum_sum] | case mp
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
i : xs.Index ⊕ ys.Index
k : (xs.sum ys).Index
h : sum i = k
⊢ i = k.unsum | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
i : xs.Index ⊕ ys.Index
k : (xs.sum ys).Index
h : sum i = k
⊢ i = k.unsum
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.sum_eq_iff_eq_unsum | [29, 1] | [32, 31] | intro h | case mpr
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
i : xs.Index ⊕ ys.Index
k : (xs.sum ys).Index
⊢ i = k.unsum → sum i = k | case mpr
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
i : xs.Index ⊕ ys.Index
k : (xs.sum ys).Index
h : i = k.unsum
⊢ sum i = k | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
i : xs.Index ⊕ ys.Index
k : (xs.sum ys).Index
⊢ i = k.unsum → sum i = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.sum_eq_iff_eq_unsum | [29, 1] | [32, 31] | rw [h, sum_unsum] | case mpr
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
i : xs.Index ⊕ ys.Index
k : (xs.sum ys).Index
h : i = k.unsum
⊢ sum i = k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
i : xs.Index ⊕ ys.Index
k : (xs.sum ys).Index
h : i = k.unsum
⊢ sum i = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.unsum_eq_iff_eq_sum | [34, 1] | [37, 31] | constructor | α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : xs.Index ⊕ ys.Index
⊢ k.unsum = i ↔ k = sum i | case mp
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : xs.Index ⊕ ys.Index
⊢ k.unsum = i → k = sum i
case mpr
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : xs.Index ⊕ ys.Index
⊢ k = sum i → k.unsum = i | Please generate a tactic in lean4 to solve the state.
STATE:
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : xs.Index ⊕ ys.Index
⊢ k.unsum = i ↔ k = sum i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.unsum_eq_iff_eq_sum | [34, 1] | [37, 31] | intro h | case mp
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : xs.Index ⊕ ys.Index
⊢ k.unsum = i → k = sum i | case mp
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : xs.Index ⊕ ys.Index
h : k.unsum = i
⊢ k = sum i | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : xs.Index ⊕ ys.Index
⊢ k.unsum = i → k = sum i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.unsum_eq_iff_eq_sum | [34, 1] | [37, 31] | rw [←h, sum_unsum] | case mp
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : xs.Index ⊕ ys.Index
h : k.unsum = i
⊢ k = sum i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : xs.Index ⊕ ys.Index
h : k.unsum = i
⊢ k = sum i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.unsum_eq_iff_eq_sum | [34, 1] | [37, 31] | intro h | case mpr
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : xs.Index ⊕ ys.Index
⊢ k = sum i → k.unsum = i | case mpr
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : xs.Index ⊕ ys.Index
h : k = sum i
⊢ k.unsum = i | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : xs.Index ⊕ ys.Index
⊢ k = sum i → k.unsum = i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.unsum_eq_iff_eq_sum | [34, 1] | [37, 31] | rw [h, unsum_sum] | case mpr
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : xs.Index ⊕ ys.Index
h : k = sum i
⊢ k.unsum = i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α✝¹ : Type u_1
xs : List α✝¹
α✝ : Type u_2
ys : List α✝
k : (xs.sum ys).Index
i : xs.Index ⊕ ys.Index
h : k = sum i
⊢ k.unsum = i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.val_sum | [48, 1] | [51, 51] | match i with
| .inl i => simp only [sum, val_append, val_map]
| .inr j => simp only [sum, val_append, val_map] | α : Type u_1
β : Type u_2
xs : List α
ys : List β
i : xs.Index ⊕ ys.Index
⊢ (match i with
| Sum.inl i => Sum.inl i.val
| Sum.inr j => Sum.inr j.val) =
(sum i).val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
β : Type u_2
xs : List α
ys : List β
i : xs.Index ⊕ ys.Index
⊢ (match i with
| Sum.inl i => Sum.inl i.val
| Sum.inr j => Sum.inr j.val) =
(sum i).val
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.val_sum | [48, 1] | [51, 51] | simp only [sum, val_append, val_map] | α : Type u_1
β : Type u_2
xs : List α
ys : List β
i✝ : xs.Index ⊕ ys.Index
i : xs.Index
⊢ (match Sum.inl i with
| Sum.inl i => Sum.inl i.val
| Sum.inr j => Sum.inr j.val) =
(sum (Sum.inl i)).val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
β : Type u_2
xs : List α
ys : List β
i✝ : xs.Index ⊕ ys.Index
i : xs.Index
⊢ (match Sum.inl i with
| Sum.inl i => Sum.inl i.val
| Sum.inr j => Sum.inr j.val) =
(sum (Sum.inl i)).val
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.val_sum | [48, 1] | [51, 51] | simp only [sum, val_append, val_map] | α : Type u_1
β : Type u_2
xs : List α
ys : List β
i : xs.Index ⊕ ys.Index
j : ys.Index
⊢ (match Sum.inr j with
| Sum.inl i => Sum.inl i.val
| Sum.inr j => Sum.inr j.val) =
(sum (Sum.inr j)).val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
β : Type u_2
xs : List α
ys : List β
i : xs.Index ⊕ ys.Index
j : ys.Index
⊢ (match Sum.inr j with
| Sum.inl i => Sum.inl i.val
| Sum.inr j => Sum.inr j.val) =
(sum (Sum.inr j)).val
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sum.lean | List.Index.val_unsum | [53, 1] | [54, 40] | rw [←sum_unsum k, val_sum, unsum_sum] | α : Type u_1
β : Type u_2
xs : List α
ys : List β
k : (xs.sum ys).Index
⊢ k.val =
match k.unsum with
| Sum.inl i => Sum.inl i.val
| Sum.inr j => Sum.inr j.val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
β : Type u_2
xs : List α
ys : List β
k : (xs.sum ys).Index
⊢ k.val =
match k.unsum with
| Sum.inl i => Sum.inl i.val
| Sum.inr j => Sum.inr j.val
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.unsigma_sigma | [17, 1] | [23, 74] | induction xs with
| nil => cases i; contradiction
| cons x xs ih =>
match i with
| ⟨head, j⟩ => simp only [sigma, unsigma, unappend_append, unmap_map]
| ⟨tail i, j⟩ => simp only [sigma, unsigma, unappend_append]; rw [ih] | α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
⊢ (sigma i).unsigma = i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
⊢ (sigma i).unsigma = i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.unsigma_sigma | [17, 1] | [23, 74] | cases i | case nil
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : [].Index) × (f i.val).Index
⊢ (sigma i).unsigma = i | case nil.mk
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
fst✝ : [].Index
snd✝ : (f fst✝.val).Index
⊢ (sigma ⟨fst✝, snd✝⟩).unsigma = ⟨fst✝, snd✝⟩ | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : [].Index) × (f i.val).Index
⊢ (sigma i).unsigma = i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.unsigma_sigma | [17, 1] | [23, 74] | contradiction | case nil.mk
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
fst✝ : [].Index
snd✝ : (f fst✝.val).Index
⊢ (sigma ⟨fst✝, snd✝⟩).unsigma = ⟨fst✝, snd✝⟩ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil.mk
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
fst✝ : [].Index
snd✝ : (f fst✝.val).Index
⊢ (sigma ⟨fst✝, snd✝⟩).unsigma = ⟨fst✝, snd✝⟩
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.unsigma_sigma | [17, 1] | [23, 74] | match i with
| ⟨head, j⟩ => simp only [sigma, unsigma, unappend_append, unmap_map]
| ⟨tail i, j⟩ => simp only [sigma, unsigma, unappend_append]; rw [ih] | case cons
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
x : α
xs : List α
ih : ∀ (i : (i : xs.Index) × (f i.val).Index), (sigma i).unsigma = i
i : (i : (x :: xs).Index) × (f i.val).Index
⊢ (sigma i).unsigma = i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
x : α
xs : List α
ih : ∀ (i : (i : xs.Index) × (f i.val).Index), (sigma i).unsigma = i
i : (i : (x :: xs).Index) × (f i.val).Index
⊢ (sigma i).unsigma = i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.unsigma_sigma | [17, 1] | [23, 74] | simp only [sigma, unsigma, unappend_append, unmap_map] | α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
x : α
xs : List α
ih : ∀ (i : (i : xs.Index) × (f i.val).Index), (sigma i).unsigma = i
i : (i : (x :: xs).Index) × (f i.val).Index
j : (f head.val).Index
⊢ (sigma ⟨head, j⟩).unsigma = ⟨head, j⟩ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
x : α
xs : List α
ih : ∀ (i : (i : xs.Index) × (f i.val).Index), (sigma i).unsigma = i
i : (i : (x :: xs).Index) × (f i.val).Index
j : (f head.val).Index
⊢ (sigma ⟨head, j⟩).unsigma = ⟨head, j⟩
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.unsigma_sigma | [17, 1] | [23, 74] | simp only [sigma, unsigma, unappend_append] | α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
x : α
xs : List α
ih : ∀ (i : (i : xs.Index) × (f i.val).Index), (sigma i).unsigma = i
i✝ : (i : (x :: xs).Index) × (f i.val).Index
i : xs.Index
j : (f i.tail.val).Index
⊢ (sigma ⟨i.tail, j⟩).unsigma = ⟨i.tail, j⟩ | α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
x : α
xs : List α
ih : ∀ (i : (i : xs.Index) × (f i.val).Index), (sigma i).unsigma = i
i✝ : (i : (x :: xs).Index) × (f i.val).Index
i : xs.Index
j : (f i.tail.val).Index
⊢ ⟨(sigma ⟨i, j⟩).unsigma.fst.tail, (sigma ⟨i, j⟩).unsigma.snd⟩ = ⟨i.tail, j⟩ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
x : α
xs : List α
ih : ∀ (i : (i : xs.Index) × (f i.val).Index), (sigma i).unsigma = i
i✝ : (i : (x :: xs).Index) × (f i.val).Index
i : xs.Index
j : (f i.tail.val).Index
⊢ (sigma ⟨i.tail, j⟩).unsigma = ⟨i... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.unsigma_sigma | [17, 1] | [23, 74] | rw [ih] | α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
x : α
xs : List α
ih : ∀ (i : (i : xs.Index) × (f i.val).Index), (sigma i).unsigma = i
i✝ : (i : (x :: xs).Index) × (f i.val).Index
i : xs.Index
j : (f i.tail.val).Index
⊢ ⟨(sigma ⟨i, j⟩).unsigma.fst.tail, (sigma ⟨i, j⟩).unsigma.snd⟩ = ⟨i.tail, j⟩ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
x : α
xs : List α
ih : ∀ (i : (i : xs.Index) × (f i.val).Index), (sigma i).unsigma = i
i✝ : (i : (x :: xs).Index) × (f i.val).Index
i : xs.Index
j : (f i.tail.val).Index
⊢ ⟨(sigma ⟨i, j⟩).unsigma.fst.tail... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.sigma_unsigma | [25, 1] | [31, 103] | induction xs with
| nil => contradiction
| cons x xs ih =>
match h : unappend k with
| .inl j => rw [unappend_eq_iff_eq_append] at h; cases h; rw [unsigma, unappend_append, sigma, map_unmap]
| .inr k => rw [unappend_eq_iff_eq_append] at h; cases h; rw [unsigma, unappend_append, sigma, ih] | α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
xs : List α
k : (xs.sigma f).Index
⊢ sigma k.unsigma = k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
xs : List α
k : (xs.sigma f).Index
⊢ sigma k.unsigma = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.sigma_unsigma | [25, 1] | [31, 103] | contradiction | case nil
α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
k : ([].sigma f).Index
⊢ sigma k.unsigma = k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
k : ([].sigma f).Index
⊢ sigma k.unsigma = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.sigma_unsigma | [25, 1] | [31, 103] | match h : unappend k with
| .inl j => rw [unappend_eq_iff_eq_append] at h; cases h; rw [unsigma, unappend_append, sigma, map_unmap]
| .inr k => rw [unappend_eq_iff_eq_append] at h; cases h; rw [unsigma, unappend_append, sigma, ih] | case cons
α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
k : ((x :: xs).sigma f).Index
⊢ sigma k.unsigma = k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
k : ((x :: xs).sigma f).Index
⊢ sigma k.unsigma = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.sigma_unsigma | [25, 1] | [31, 103] | rw [unappend_eq_iff_eq_append] at h | α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
k : ((x :: xs).sigma f).Index
j : ((fun a => List.map (Sigma.mk a) (f a)) x).Index
h : k.unappend = Sum.inl j
⊢ sigma k.unsigma = k | α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
k : ((x :: xs).sigma f).Index
j : ((fun a => List.map (Sigma.mk a) (f a)) x).Index
h : k = append (Sum.inl j)
⊢ sigma k.unsigma = k | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
k : ((x :: xs).sigma f).Index
j : ((fun a => List.map (Sigma.mk a) (f a)) x).Index
h : k.unappend = Sum.inl j
⊢ sigma k.unsigma = k... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.sigma_unsigma | [25, 1] | [31, 103] | cases h | α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
k : ((x :: xs).sigma f).Index
j : ((fun a => List.map (Sigma.mk a) (f a)) x).Index
h : k = append (Sum.inl j)
⊢ sigma k.unsigma = k | case refl
α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
j : ((fun a => List.map (Sigma.mk a) (f a)) x).Index
⊢ sigma (append (Sum.inl j)).unsigma = append (Sum.inl j) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
k : ((x :: xs).sigma f).Index
j : ((fun a => List.map (Sigma.mk a) (f a)) x).Index
h : k = append (Sum.inl j)
⊢ sigma k.unsigma = k... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.sigma_unsigma | [25, 1] | [31, 103] | rw [unsigma, unappend_append, sigma, map_unmap] | case refl
α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
j : ((fun a => List.map (Sigma.mk a) (f a)) x).Index
⊢ sigma (append (Sum.inl j)).unsigma = append (Sum.inl j) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
j : ((fun a => List.map (Sigma.mk a) (f a)) x).Index
⊢ sigma (append (Sum.inl j)).unsigma = append (Sum.inl j)
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.sigma_unsigma | [25, 1] | [31, 103] | rw [unappend_eq_iff_eq_append] at h | α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
k✝ : ((x :: xs).sigma f).Index
k : (List.map (fun a => List.map (Sigma.mk a) (f a)) xs).join.Index
h : k✝.unappend = Sum.inr k
⊢ sigma k✝.unsigma = k✝ | α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
k✝ : ((x :: xs).sigma f).Index
k : (List.map (fun a => List.map (Sigma.mk a) (f a)) xs).join.Index
h : k✝ = append (Sum.inr k)
⊢ sigma k✝.unsigma = k✝ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
k✝ : ((x :: xs).sigma f).Index
k : (List.map (fun a => List.map (Sigma.mk a) (f a)) xs).join.Index
h : k✝.unappend = Sum.inr k
⊢ si... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.sigma_unsigma | [25, 1] | [31, 103] | cases h | α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
k✝ : ((x :: xs).sigma f).Index
k : (List.map (fun a => List.map (Sigma.mk a) (f a)) xs).join.Index
h : k✝ = append (Sum.inr k)
⊢ sigma k✝.unsigma = k✝ | case refl
α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
k : (List.map (fun a => List.map (Sigma.mk a) (f a)) xs).join.Index
⊢ sigma (append (Sum.inr k)).unsigma = append (Sum.inr k) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
k✝ : ((x :: xs).sigma f).Index
k : (List.map (fun a => List.map (Sigma.mk a) (f a)) xs).join.Index
h : k✝ = append (Sum.inr k)
⊢ si... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.sigma_unsigma | [25, 1] | [31, 103] | rw [unsigma, unappend_append, sigma, ih] | case refl
α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
k : (List.map (fun a => List.map (Sigma.mk a) (f a)) xs).join.Index
⊢ sigma (append (Sum.inr k)).unsigma = append (Sum.inr k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
α : Type u_1
σ✝ : α → Type u_2
f : (a : α) → List (σ✝ a)
x : α
xs : List α
ih : ∀ (k : (xs.sigma f).Index), sigma k.unsigma = k
k : (List.map (fun a => List.map (Sigma.mk a) (f a)) xs).join.Index
⊢ sigma (append (Sum.inr k)).unsigma = append (Sum.in... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.sigma_eq_iff_eq_unsigma | [33, 1] | [36, 41] | constructor | α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
k : (xs.sigma f).Index
⊢ sigma i = k ↔ i = k.unsigma | case mp
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
k : (xs.sigma f).Index
⊢ sigma i = k → i = k.unsigma
case mpr
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
k : (xs.sigma f).Index
⊢ i = k.unsigma → ... | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
k : (xs.sigma f).Index
⊢ sigma i = k ↔ i = k.unsigma
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.sigma_eq_iff_eq_unsigma | [33, 1] | [36, 41] | intro h | case mp
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
k : (xs.sigma f).Index
⊢ sigma i = k → i = k.unsigma | case mp
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
k : (xs.sigma f).Index
h : sigma i = k
⊢ i = k.unsigma | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
k : (xs.sigma f).Index
⊢ sigma i = k → i = k.unsigma
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.sigma_eq_iff_eq_unsigma | [33, 1] | [36, 41] | cases h | case mp
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
k : (xs.sigma f).Index
h : sigma i = k
⊢ i = k.unsigma | case mp.refl
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
⊢ i = (sigma i).unsigma | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
k : (xs.sigma f).Index
h : sigma i = k
⊢ i = k.unsigma
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.sigma_eq_iff_eq_unsigma | [33, 1] | [36, 41] | rw [unsigma_sigma] | case mp.refl
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
⊢ i = (sigma i).unsigma | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.refl
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
⊢ i = (sigma i).unsigma
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.sigma_eq_iff_eq_unsigma | [33, 1] | [36, 41] | intro h | case mpr
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
k : (xs.sigma f).Index
⊢ i = k.unsigma → sigma i = k | case mpr
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
k : (xs.sigma f).Index
h : i = k.unsigma
⊢ sigma i = k | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
k : (xs.sigma f).Index
⊢ i = k.unsigma → sigma i = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.sigma_eq_iff_eq_unsigma | [33, 1] | [36, 41] | cases h | case mpr
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
k : (xs.sigma f).Index
h : i = k.unsigma
⊢ sigma i = k | case mpr.refl
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
k : (xs.sigma f).Index
⊢ sigma k.unsigma = k | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
k : (xs.sigma f).Index
h : i = k.unsigma
⊢ sigma i = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.sigma_eq_iff_eq_unsigma | [33, 1] | [36, 41] | rw [sigma_unsigma] | case mpr.refl
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
k : (xs.sigma f).Index
⊢ sigma k.unsigma = k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.refl
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
k : (xs.sigma f).Index
⊢ sigma k.unsigma = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.unsigma_eq_iff_eq_sigma | [38, 1] | [41, 41] | constructor | α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
k : (xs.sigma f).Index
i : (i : xs.Index) × (f i.val).Index
⊢ k.unsigma = i ↔ k = sigma i | case mp
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
k : (xs.sigma f).Index
i : (i : xs.Index) × (f i.val).Index
⊢ k.unsigma = i → k = sigma i
case mpr
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
k : (xs.sigma f).Index
i : (i : xs.Index) × (f i.val).Index
⊢ k = sigma i → k.... | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
k : (xs.sigma f).Index
i : (i : xs.Index) × (f i.val).Index
⊢ k.unsigma = i ↔ k = sigma i
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.