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/Index/Sigma.lean | List.Index.unsigma_eq_iff_eq_sigma | [38, 1] | [41, 41] | intro h | 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 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
h : k.unsigma = i
⊢ k = sigma i | 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)
k : (xs.sigma f).Index
i : (i : xs.Index) × (f i.val).Index
⊢ k.unsigma = i → k = sigma i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.unsigma_eq_iff_eq_sigma | [38, 1] | [41, 41] | cases h | 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
h : k.unsigma = i
⊢ k = sigma i | case mp.refl
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
k : (xs.sigma f).Index
⊢ k = sigma 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)
k : (xs.sigma f).Index
i : (i : xs.Index) × (f i.val).Index
h : k.unsigma = i
⊢ k = sigma i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.unsigma_eq_iff_eq_sigma | [38, 1] | [41, 41] | rw [sigma_unsigma] | case mp.refl
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
k : (xs.sigma f).Index
⊢ k = sigma k.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)
k : (xs.sigma f).Index
⊢ k = sigma k.unsigma
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.unsigma_eq_iff_eq_sigma | [38, 1] | [41, 41] | intro h | 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.unsigma = 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
h : k = sigma i
⊢ k.unsigma = i | 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)
k : (xs.sigma f).Index
i : (i : xs.Index) × (f i.val).Index
⊢ k = sigma i → k.unsigma = i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.unsigma_eq_iff_eq_sigma | [38, 1] | [41, 41] | cases h | 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
h : k = sigma i
⊢ k.unsigma = i | case mpr.refl
α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
⊢ (sigma i).unsigma = i | 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)
k : (xs.sigma f).Index
i : (i : xs.Index) × (f i.val).Index
h : k = sigma i
⊢ k.unsigma = i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.unsigma_eq_iff_eq_sigma | [38, 1] | [41, 41] | rw [unsigma_sigma] | case mpr.refl
α : 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:
case mpr.refl
α : 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.val_sigma | [52, 1] | [58, 52] | induction xs with
| nil => cases i; contradiction
| cons x xs ih =>
match i with
| ⟨head, j⟩ => rw [sigma, val_append_inl, val_map]
| ⟨tail i, j⟩ => rw [sigma, val_append_inr, ih] | α : Type u_1
xs : List α
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : xs.Index) × (f i.val).Index
⊢ (sigma i).val = ⟨i.fst.val, i.snd.val⟩ | 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).val = ⟨i.fst.val, i.snd.val⟩
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.val_sigma | [52, 1] | [58, 52] | cases i | case nil
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
i : (i : [].Index) × (f i.val).Index
⊢ (sigma i).val = ⟨i.fst.val, i.snd.val⟩ | case nil.mk
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
fst✝ : [].Index
snd✝ : (f fst✝.val).Index
⊢ (sigma ⟨fst✝, snd✝⟩).val = ⟨⟨fst✝, snd✝⟩.fst.val, ⟨fst✝, snd✝⟩.snd.val⟩ | 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).val = ⟨i.fst.val, i.snd.val⟩
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.val_sigma | [52, 1] | [58, 52] | contradiction | case nil.mk
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
fst✝ : [].Index
snd✝ : (f fst✝.val).Index
⊢ (sigma ⟨fst✝, snd✝⟩).val = ⟨⟨fst✝, snd✝⟩.fst.val, ⟨fst✝, snd✝⟩.snd.val⟩ | 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✝⟩).val = ⟨⟨fst✝, snd✝⟩.fst.val, ⟨fst✝, snd✝⟩.snd.val⟩
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.val_sigma | [52, 1] | [58, 52] | match i with
| ⟨head, j⟩ => rw [sigma, val_append_inl, val_map]
| ⟨tail i, j⟩ => rw [sigma, val_append_inr, 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).val = ⟨i.fst.val, i.snd.val⟩
i : (i : (x :: xs).Index) × (f i.val).Index
⊢ (sigma i).val = ⟨i.fst.val, i.snd.val⟩ | 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).val = ⟨i.fst.val, i.snd.val⟩
i : (i : (x :: xs).Index) × (f i.val).Index
⊢ (sigma i).val = ⟨i.fst.val, i.snd.val⟩
TACTI... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.val_sigma | [52, 1] | [58, 52] | rw [sigma, val_append_inl, val_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).val = ⟨i.fst.val, i.snd.val⟩
i : (i : (x :: xs).Index) × (f i.val).Index
j : (f head.val).Index
⊢ (sigma ⟨head, j⟩).val = ⟨⟨head, j⟩.fst.val, ⟨head, j⟩.snd.val⟩ | 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).val = ⟨i.fst.val, i.snd.val⟩
i : (i : (x :: xs).Index) × (f i.val).Index
j : (f head.val).Index
⊢ (sigma ⟨head, j⟩).val = ⟨⟨head,... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.val_sigma | [52, 1] | [58, 52] | rw [sigma, val_append_inr, 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).val = ⟨i.fst.val, i.snd.val⟩
i✝ : (i : (x :: xs).Index) × (f i.val).Index
i : xs.Index
j : (f i.tail.val).Index
⊢ (sigma ⟨i.tail, j⟩).val = ⟨⟨i.tail, j⟩.fst.val, ⟨i.tail, j⟩.snd.val⟩ | 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).val = ⟨i.fst.val, i.snd.val⟩
i✝ : (i : (x :: xs).Index) × (f i.val).Index
i : xs.Index
j : (f i.tail.val).Index
⊢ (sigma ⟨i.tail,... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Sigma.lean | List.Index.val_unsigma | [60, 1] | [61, 50] | rw [←sigma_unsigma k, val_sigma, unsigma_sigma] | α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
k : (xs.sigma f).Index
⊢ ⟨k.unsigma.fst.val, k.unsigma.snd.val⟩ = k.val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
k : (xs.sigma f).Index
⊢ ⟨k.unsigma.fst.val, k.unsigma.snd.val⟩ = k.val
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.unpi_pi | [24, 1] | [28, 60] | funext i | α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h : (i : xs.Index) → (f i.val).Index
⊢ (pi h).unpi = h | case h
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h : (i : xs.Index) → (f i.val).Index
i : xs.Index
⊢ (pi h).unpi i = h i | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h : (i : xs.Index) → (f i.val).Index
⊢ (pi h).unpi = h
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.unpi_pi | [24, 1] | [28, 60] | induction i with
| head => simp only [pi, unpi]; rw [unbind_bind, unmap_map]
| tail i ih => simp only [pi, unpi]; rw [unbind_bind, ih] | case h
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h : (i : xs.Index) → (f i.val).Index
i : xs.Index
⊢ (pi h).unpi i = h i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h : (i : xs.Index) → (f i.val).Index
i : xs.Index
⊢ (pi h).unpi i = h i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.unpi_pi | [24, 1] | [28, 60] | simp only [pi, unpi] | case h.head
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
x✝ : α
xs✝ : List α
h : (i : (x✝ :: xs✝).Index) → (f i.val).Index
⊢ (pi h).unpi head = h head | case h.head
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
x✝ : α
xs✝ : List α
h : (i : (x✝ :: xs✝).Index) → (f i.val).Index
⊢ unmap
(fun y i =>
match i with
| head => y
| i.tail =>
(unbind
(fun ys =>
List.map
... | Please generate a tactic in lean4 to solve the state.
STATE:
case h.head
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
x✝ : α
xs✝ : List α
h : (i : (x✝ :: xs✝).Index) → (f i.val).Index
⊢ (pi h).unpi head = h head
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.unpi_pi | [24, 1] | [28, 60] | rw [unbind_bind, unmap_map] | case h.head
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
x✝ : α
xs✝ : List α
h : (i : (x✝ :: xs✝).Index) → (f i.val).Index
⊢ unmap
(fun y i =>
match i with
| head => y
| i.tail =>
(unbind
(fun ys =>
List.map
... | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.head
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
x✝ : α
xs✝ : List α
h : (i : (x✝ :: xs✝).Index) → (f i.val).Index
⊢ unmap
(fun y i =>
match i with
| head => y
| i.tail =>
(unbind
... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.unpi_pi | [24, 1] | [28, 60] | simp only [pi, unpi] | case h.tail
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs xs✝ : List α
x✝ : α
i : xs✝.Index
ih : ∀ (h : (i : xs✝.Index) → (f i.val).Index), (pi h).unpi i = h i
h : (i : (x✝ :: xs✝).Index) → (f i.val).Index
⊢ (pi h).unpi i.tail = h i.tail | case h.tail
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs xs✝ : List α
x✝ : α
i : xs✝.Index
ih : ∀ (h : (i : xs✝.Index) → (f i.val).Index), (pi h).unpi i = h i
h : (i : (x✝ :: xs✝).Index) → (f i.val).Index
⊢ (unbind
(fun ys =>
List.map
(fun y i =>
... | Please generate a tactic in lean4 to solve the state.
STATE:
case h.tail
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs xs✝ : List α
x✝ : α
i : xs✝.Index
ih : ∀ (h : (i : xs✝.Index) → (f i.val).Index), (pi h).unpi i = h i
h : (i : (x✝ :: xs✝).Index) → (f i.val).Index
⊢ (pi h).unpi i.tail = h i.tail
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.unpi_pi | [24, 1] | [28, 60] | rw [unbind_bind, ih] | case h.tail
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs xs✝ : List α
x✝ : α
i : xs✝.Index
ih : ∀ (h : (i : xs✝.Index) → (f i.val).Index), (pi h).unpi i = h i
h : (i : (x✝ :: xs✝).Index) → (f i.val).Index
⊢ (unbind
(fun ys =>
List.map
(fun y i =>
... | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.tail
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs xs✝ : List α
x✝ : α
i : xs✝.Index
ih : ∀ (h : (i : xs✝.Index) → (f i.val).Index), (pi h).unpi i = h i
h : (i : (x✝ :: xs✝).Index) → (f i.val).Index
⊢ (unbind
(fun ys =>
... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.pi_unpi | [30, 1] | [42, 38] | cases k | case nil
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
k : (List.pi f []).Index
⊢ pi k.unpi = k | case nil.head
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
⊢ pi head.unpi = head
case nil.tail
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
a✝ : [].Index
⊢ pi a✝.tail.unpi = a✝.tail | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
k : (List.pi f []).Index
⊢ pi k.unpi = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.pi_unpi | [30, 1] | [42, 38] | rfl | case nil.head
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
⊢ pi head.unpi = head | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil.head
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
⊢ pi head.unpi = head
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.pi_unpi | [30, 1] | [42, 38] | contradiction | case nil.tail
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
a✝ : [].Index
⊢ pi a✝.tail.unpi = a✝.tail | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil.tail
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
a✝ : [].Index
⊢ pi a✝.tail.unpi = a✝.tail
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.pi_unpi | [30, 1] | [42, 38] | match h : unbind _ k with
| ⟨k₁,k₂⟩ =>
rw [unbind_eq_iff_eq_bind] at h
cases h
simp only [pi, unpi]
rw [unbind_bind, ih, map_unmap] | case cons
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs✝ : List α
x : α
xs : List α
ih : ∀ (k : (List.pi f xs).Index), pi k.unpi = k
k : (List.pi f (x :: xs)).Index
⊢ pi k.unpi = k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs✝ : List α
x : α
xs : List α
ih : ∀ (k : (List.pi f xs).Index), pi k.unpi = k
k : (List.pi f (x :: xs)).Index
⊢ pi k.unpi = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.pi_unpi | [30, 1] | [42, 38] | rw [unbind_eq_iff_eq_bind] at h | α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs✝ : List α
x : α
xs : List α
ih : ∀ (k : (List.pi f xs).Index), pi k.unpi = k
k : (List.pi f (x :: xs)).Index
k₁ : (List.pi f xs).Index
k₂ :
(List.map
(fun y i =>
match i with
| head => y
| i.tail => k₁.val i)
(f x)).Index
h ... | α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs✝ : List α
x : α
xs : List α
ih : ∀ (k : (List.pi f xs).Index), pi k.unpi = k
k : (List.pi f (x :: xs)).Index
k₁ : (List.pi f xs).Index
k₂ :
(List.map
(fun y i =>
match i with
| head => y
| i.tail => k₁.val i)
(f x)).Index
h ... | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs✝ : List α
x : α
xs : List α
ih : ∀ (k : (List.pi f xs).Index), pi k.unpi = k
k : (List.pi f (x :: xs)).Index
k₁ : (List.pi f xs).Index
k₂ :
(List.map
(fun y i =>
match i with
| ... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.pi_unpi | [30, 1] | [42, 38] | cases h | α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs✝ : List α
x : α
xs : List α
ih : ∀ (k : (List.pi f xs).Index), pi k.unpi = k
k : (List.pi f (x :: xs)).Index
k₁ : (List.pi f xs).Index
k₂ :
(List.map
(fun y i =>
match i with
| head => y
| i.tail => k₁.val i)
(f x)).Index
h ... | case refl
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs✝ : List α
x : α
xs : List α
ih : ∀ (k : (List.pi f xs).Index), pi k.unpi = k
k₁ : (List.pi f xs).Index
k₂ :
(List.map
(fun y i =>
match i with
| head => y
| i.tail => k₁.val i)
(f x)).Index
⊢ pi
(bind
... | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs✝ : List α
x : α
xs : List α
ih : ∀ (k : (List.pi f xs).Index), pi k.unpi = k
k : (List.pi f (x :: xs)).Index
k₁ : (List.pi f xs).Index
k₂ :
(List.map
(fun y i =>
match i with
| ... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.pi_unpi | [30, 1] | [42, 38] | simp only [pi, unpi] | case refl
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs✝ : List α
x : α
xs : List α
ih : ∀ (k : (List.pi f xs).Index), pi k.unpi = k
k₁ : (List.pi f xs).Index
k₂ :
(List.map
(fun y i =>
match i with
| head => y
| i.tail => k₁.val i)
(f x)).Index
⊢ pi
(bind
... | case refl
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs✝ : List α
x : α
xs : List α
ih : ∀ (k : (List.pi f xs).Index), pi k.unpi = k
k₁ : (List.pi f xs).Index
k₂ :
(List.map
(fun y i =>
match i with
| head => y
| i.tail => k₁.val i)
(f x)).Index
⊢ bind
(fun ys =>
... | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs✝ : List α
x : α
xs : List α
ih : ∀ (k : (List.pi f xs).Index), pi k.unpi = k
k₁ : (List.pi f xs).Index
k₂ :
(List.map
(fun y i =>
match i with
| head => y
| i.... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.pi_unpi | [30, 1] | [42, 38] | rw [unbind_bind, ih, map_unmap] | case refl
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs✝ : List α
x : α
xs : List α
ih : ∀ (k : (List.pi f xs).Index), pi k.unpi = k
k₁ : (List.pi f xs).Index
k₂ :
(List.map
(fun y i =>
match i with
| head => y
| i.tail => k₁.val i)
(f x)).Index
⊢ bind
(fun ys =>
... | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs✝ : List α
x : α
xs : List α
ih : ∀ (k : (List.pi f xs).Index), pi k.unpi = k
k₁ : (List.pi f xs).Index
k₂ :
(List.map
(fun y i =>
match i with
| head => y
| i.... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.pi_eq_iff_eq_unpi | [44, 1] | [47, 29] | constructor | α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h : (i : xs.Index) → (f i.val).Index
k : (List.pi f xs).Index
⊢ pi h = k ↔ h = k.unpi | case mp
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h : (i : xs.Index) → (f i.val).Index
k : (List.pi f xs).Index
⊢ pi h = k → h = k.unpi
case mpr
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h : (i : xs.Index) → (f i.val).Index
k : (List.pi f xs).Index
⊢ h = k.unpi → pi h ... | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h : (i : xs.Index) → (f i.val).Index
k : (List.pi f xs).Index
⊢ pi h = k ↔ h = k.unpi
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.pi_eq_iff_eq_unpi | [44, 1] | [47, 29] | intro h | case mp
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h : (i : xs.Index) → (f i.val).Index
k : (List.pi f xs).Index
⊢ pi h = k → h = k.unpi | case mp
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h✝ : (i : xs.Index) → (f i.val).Index
k : (List.pi f xs).Index
h : pi h✝ = k
⊢ h✝ = k.unpi | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h : (i : xs.Index) → (f i.val).Index
k : (List.pi f xs).Index
⊢ pi h = k → h = k.unpi
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.pi_eq_iff_eq_unpi | [44, 1] | [47, 29] | rw [←h, unpi_pi] | case mp
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h✝ : (i : xs.Index) → (f i.val).Index
k : (List.pi f xs).Index
h : pi h✝ = k
⊢ h✝ = k.unpi | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h✝ : (i : xs.Index) → (f i.val).Index
k : (List.pi f xs).Index
h : pi h✝ = k
⊢ h✝ = k.unpi
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.pi_eq_iff_eq_unpi | [44, 1] | [47, 29] | intro h | case mpr
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h : (i : xs.Index) → (f i.val).Index
k : (List.pi f xs).Index
⊢ h = k.unpi → pi h = k | case mpr
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h✝ : (i : xs.Index) → (f i.val).Index
k : (List.pi f xs).Index
h : h✝ = k.unpi
⊢ pi h✝ = k | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h : (i : xs.Index) → (f i.val).Index
k : (List.pi f xs).Index
⊢ h = k.unpi → pi h = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.pi_eq_iff_eq_unpi | [44, 1] | [47, 29] | rw [h, pi_unpi] | case mpr
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h✝ : (i : xs.Index) → (f i.val).Index
k : (List.pi f xs).Index
h : h✝ = k.unpi
⊢ pi h✝ = k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α : Type u_1
β : α → Type u_2
f : (x : α) → List (β x)
xs : List α
h✝ : (i : xs.Index) → (f i.val).Index
k : (List.pi f xs).Index
h : h✝ = k.unpi
⊢ pi h✝ = k
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.unpi_eq_iff_eq_pi | [49, 1] | [52, 29] | constructor | α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
k : (List.pi f xs).Index
h : (i : xs.Index) → (f i.val).Index
⊢ k.unpi = h ↔ k = pi h | case mp
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
k : (List.pi f xs).Index
h : (i : xs.Index) → (f i.val).Index
⊢ k.unpi = h → k = pi h
case mpr
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
k : (List.pi f xs).Index
h : (i : xs.Index) → (f i.val).Index
⊢ k = pi h → k.unpi ... | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
k : (List.pi f xs).Index
h : (i : xs.Index) → (f i.val).Index
⊢ k.unpi = h ↔ k = pi h
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.unpi_eq_iff_eq_pi | [49, 1] | [52, 29] | intro h | case mp
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
k : (List.pi f xs).Index
h : (i : xs.Index) → (f i.val).Index
⊢ k.unpi = h → k = pi h | case mp
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
k : (List.pi f xs).Index
h✝ : (i : xs.Index) → (f i.val).Index
h : k.unpi = h✝
⊢ k = pi h✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
k : (List.pi f xs).Index
h : (i : xs.Index) → (f i.val).Index
⊢ k.unpi = h → k = pi h
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.unpi_eq_iff_eq_pi | [49, 1] | [52, 29] | rw [←h, pi_unpi] | case mp
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
k : (List.pi f xs).Index
h✝ : (i : xs.Index) → (f i.val).Index
h : k.unpi = h✝
⊢ k = pi h✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
k : (List.pi f xs).Index
h✝ : (i : xs.Index) → (f i.val).Index
h : k.unpi = h✝
⊢ k = pi h✝
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.unpi_eq_iff_eq_pi | [49, 1] | [52, 29] | intro h | case mpr
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
k : (List.pi f xs).Index
h : (i : xs.Index) → (f i.val).Index
⊢ k = pi h → k.unpi = h | case mpr
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
k : (List.pi f xs).Index
h✝ : (i : xs.Index) → (f i.val).Index
h : k = pi h✝
⊢ k.unpi = h✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
k : (List.pi f xs).Index
h : (i : xs.Index) → (f i.val).Index
⊢ k = pi h → k.unpi = h
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Pi.lean | List.Index.unpi_eq_iff_eq_pi | [49, 1] | [52, 29] | rw [h, unpi_pi] | case mpr
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
k : (List.pi f xs).Index
h✝ : (i : xs.Index) → (f i.val).Index
h : k = pi h✝
⊢ k.unpi = h✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α : Type u_2
β : α → Type u_1
f : (x : α) → List (β x)
xs : List α
k : (List.pi f xs).Index
h✝ : (i : xs.Index) → (f i.val).Index
h : k = pi h✝
⊢ k.unpi = h✝
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.all_zero | [10, 9] | [10, 84] | simp [Fin.all] | p : Fin 0 → Bool
⊢ Fin.all p = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
p : Fin 0 → Bool
⊢ Fin.all p = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.all_succ | [12, 1] | [13, 33] | simp [Fin.all, Fin.foldr_succ] | n : Nat
p : Fin (n + 1) → Bool
⊢ Fin.all p = (p 0 && Fin.all (p ∘ succ)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
⊢ Fin.all p = (p 0 && Fin.all (p ∘ succ))
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.forall_eq_true_of_all_eq_true | [15, 1] | [21, 77] | rw [Fin.all, Fin.foldr_succ, Bool.and_eq_true] at h | n : Nat
p : Fin (n + 1) → Bool
h : Fin.all p = true
isLt✝ : 0 < n + 1
⊢ p ⟨0, isLt✝⟩ = true | n : Nat
p : Fin (n + 1) → Bool
h : p 0 = true ∧ foldr n (fun i v => p i.succ && v) true = true
isLt✝ : 0 < n + 1
⊢ p ⟨0, isLt✝⟩ = true | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h : Fin.all p = true
isLt✝ : 0 < n + 1
⊢ p ⟨0, isLt✝⟩ = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.forall_eq_true_of_all_eq_true | [15, 1] | [21, 77] | exact h.left | n : Nat
p : Fin (n + 1) → Bool
h : p 0 = true ∧ foldr n (fun i v => p i.succ && v) true = true
isLt✝ : 0 < n + 1
⊢ p ⟨0, isLt✝⟩ = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h : p 0 = true ∧ foldr n (fun i v => p i.succ && v) true = true
isLt✝ : 0 < n + 1
⊢ p ⟨0, isLt✝⟩ = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.forall_eq_true_of_all_eq_true | [15, 1] | [21, 77] | rw [Fin.all, Fin.foldr_succ, Bool.and_eq_true] at h | n : Nat
p : Fin (n + 1) → Bool
h : Fin.all p = true
i : Nat
hi : i + 1 < n + 1
⊢ p ⟨i + 1, hi⟩ = true | n : Nat
p : Fin (n + 1) → Bool
h : p 0 = true ∧ foldr n (fun i v => p i.succ && v) true = true
i : Nat
hi : i + 1 < n + 1
⊢ p ⟨i + 1, hi⟩ = true | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h : Fin.all p = true
i : Nat
hi : i + 1 < n + 1
⊢ p ⟨i + 1, hi⟩ = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.forall_eq_true_of_all_eq_true | [15, 1] | [21, 77] | exact forall_eq_true_of_all_eq_true h.right ⟨i, Nat.lt_of_succ_lt_succ hi⟩ | n : Nat
p : Fin (n + 1) → Bool
h : p 0 = true ∧ foldr n (fun i v => p i.succ && v) true = true
i : Nat
hi : i + 1 < n + 1
⊢ p ⟨i + 1, hi⟩ = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h : p 0 = true ∧ foldr n (fun i v => p i.succ && v) true = true
i : Nat
hi : i + 1 < n + 1
⊢ p ⟨i + 1, hi⟩ = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.exists_eq_false_of_all_eq_false | [23, 1] | [30, 55] | simp at h | p : Fin 0 → Bool
h : Fin.all p = false
⊢ ∃ i, p i = false | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
p : Fin 0 → Bool
h : Fin.all p = false
⊢ ∃ i, p i = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.exists_eq_false_of_all_eq_false | [23, 1] | [30, 55] | rw [Fin.all, Fin.foldr_succ, Bool.and_eq_false_iff] at h | n : Nat
p : Fin (n + 1) → Bool
h : Fin.all p = false
⊢ ∃ i, p i = false | n : Nat
p : Fin (n + 1) → Bool
h : p 0 = false ∨ foldr n (fun i v => p i.succ && v) true = false
⊢ ∃ i, p i = false | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h : Fin.all p = false
⊢ ∃ i, p i = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.exists_eq_false_of_all_eq_false | [23, 1] | [30, 55] | match h with
| .inl h => exists ⟨0, Nat.zero_lt_succ n⟩
| .inr h => match exists_eq_false_of_all_eq_false h with
| ⟨⟨i,hi⟩,hp⟩ => exists ⟨i+1, Nat.succ_lt_succ hi⟩ | n : Nat
p : Fin (n + 1) → Bool
h : p 0 = false ∨ foldr n (fun i v => p i.succ && v) true = false
⊢ ∃ i, p i = false | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h : p 0 = false ∨ foldr n (fun i v => p i.succ && v) true = false
⊢ ∃ i, p i = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.exists_eq_false_of_all_eq_false | [23, 1] | [30, 55] | exists ⟨0, Nat.zero_lt_succ n⟩ | n : Nat
p : Fin (n + 1) → Bool
h✝ : p 0 = false ∨ foldr n (fun i v => p i.succ && v) true = false
h : p 0 = false
⊢ ∃ i, p i = false | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h✝ : p 0 = false ∨ foldr n (fun i v => p i.succ && v) true = false
h : p 0 = false
⊢ ∃ i, p i = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.exists_eq_false_of_all_eq_false | [23, 1] | [30, 55] | match exists_eq_false_of_all_eq_false h with
| ⟨⟨i,hi⟩,hp⟩ => exists ⟨i+1, Nat.succ_lt_succ hi⟩ | n : Nat
p : Fin (n + 1) → Bool
h✝ : p 0 = false ∨ foldr n (fun i v => p i.succ && v) true = false
h : foldr n (fun i v => p i.succ && v) true = false
⊢ ∃ i, p i = false | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h✝ : p 0 = false ∨ foldr n (fun i v => p i.succ && v) true = false
h : foldr n (fun i v => p i.succ && v) true = false
⊢ ∃ i, p i = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.exists_eq_false_of_all_eq_false | [23, 1] | [30, 55] | exists ⟨i+1, Nat.succ_lt_succ hi⟩ | n : Nat
p : Fin (n + 1) → Bool
h✝ : p 0 = false ∨ foldr n (fun i v => p i.succ && v) true = false
h : foldr n (fun i v => p i.succ && v) true = false
i : Nat
hi : i < n
hp : p ⟨i, hi⟩.succ = false
⊢ ∃ i, p i = false | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h✝ : p 0 = false ∨ foldr n (fun i v => p i.succ && v) true = false
h : foldr n (fun i v => p i.succ && v) true = false
i : Nat
hi : i < n
hp : p ⟨i, hi⟩.succ = false
⊢ ∃ i, p i = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_forall_eq_all | [43, 1] | [58, 16] | match h : Fin.all fun i => decide (p i) with
| true =>
have h := forall_eq_true_of_all_eq_true h
apply decide_eq_true
intro i
apply of_decide_eq_true
exact h i
| false =>
match exists_eq_false_of_all_eq_false h with
| ⟨i, hi⟩ =>
have hi := of_decide_eq_false hi
apply decide_eq_false
intro h
... | n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
⊢ decide (∀ (i : Fin n), p i) = Fin.all fun i => decide (p i) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
⊢ decide (∀ (i : Fin n), p i) = Fin.all fun i => decide (p i)
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_forall_eq_all | [43, 1] | [58, 16] | have h := forall_eq_true_of_all_eq_true h | n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h : (Fin.all fun i => decide (p i)) = true
⊢ decide (∀ (i : Fin n), p i) = true | n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = true
h : ∀ (i : Fin n), decide (p i) = true
⊢ decide (∀ (i : Fin n), p i) = true | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h : (Fin.all fun i => decide (p i)) = true
⊢ decide (∀ (i : Fin n), p i) = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_forall_eq_all | [43, 1] | [58, 16] | apply decide_eq_true | n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = true
h : ∀ (i : Fin n), decide (p i) = true
⊢ decide (∀ (i : Fin n), p i) = true | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = true
h : ∀ (i : Fin n), decide (p i) = true
⊢ ∀ (i : Fin n), p i | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = true
h : ∀ (i : Fin n), decide (p i) = true
⊢ decide (∀ (i : Fin n), p i) = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_forall_eq_all | [43, 1] | [58, 16] | intro i | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = true
h : ∀ (i : Fin n), decide (p i) = true
⊢ ∀ (i : Fin n), p i | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = true
h : ∀ (i : Fin n), decide (p i) = true
i : Fin n
⊢ p i | Please generate a tactic in lean4 to solve the state.
STATE:
case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = true
h : ∀ (i : Fin n), decide (p i) = true
⊢ ∀ (i : Fin n), p i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_forall_eq_all | [43, 1] | [58, 16] | apply of_decide_eq_true | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = true
h : ∀ (i : Fin n), decide (p i) = true
i : Fin n
⊢ p i | case a.a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = true
h : ∀ (i : Fin n), decide (p i) = true
i : Fin n
⊢ decide (p i) = true | Please generate a tactic in lean4 to solve the state.
STATE:
case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = true
h : ∀ (i : Fin n), decide (p i) = true
i : Fin n
⊢ p i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_forall_eq_all | [43, 1] | [58, 16] | exact h i | case a.a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = true
h : ∀ (i : Fin n), decide (p i) = true
i : Fin n
⊢ decide (p i) = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = true
h : ∀ (i : Fin n), decide (p i) = true
i : Fin n
⊢ decide (p i) = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_forall_eq_all | [43, 1] | [58, 16] | match exists_eq_false_of_all_eq_false h with
| ⟨i, hi⟩ =>
have hi := of_decide_eq_false hi
apply decide_eq_false
intro h
apply hi
exact h i | n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h : (Fin.all fun i => decide (p i)) = false
⊢ decide (∀ (i : Fin n), p i) = false | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h : (Fin.all fun i => decide (p i)) = false
⊢ decide (∀ (i : Fin n), p i) = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_forall_eq_all | [43, 1] | [58, 16] | have hi := of_decide_eq_false hi | n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h : (Fin.all fun i => decide (p i)) = false
i : Fin n
hi : decide (p i) = false
⊢ decide (∀ (i : Fin n), p i) = false | n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h : (Fin.all fun i => decide (p i)) = false
i : Fin n
hi✝ : decide (p i) = false
hi : ¬p i
⊢ decide (∀ (i : Fin n), p i) = false | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h : (Fin.all fun i => decide (p i)) = false
i : Fin n
hi : decide (p i) = false
⊢ decide (∀ (i : Fin n), p i) = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_forall_eq_all | [43, 1] | [58, 16] | apply decide_eq_false | n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h : (Fin.all fun i => decide (p i)) = false
i : Fin n
hi✝ : decide (p i) = false
hi : ¬p i
⊢ decide (∀ (i : Fin n), p i) = false | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h : (Fin.all fun i => decide (p i)) = false
i : Fin n
hi✝ : decide (p i) = false
hi : ¬p i
⊢ ¬∀ (i : Fin n), p i | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h : (Fin.all fun i => decide (p i)) = false
i : Fin n
hi✝ : decide (p i) = false
hi : ¬p i
⊢ decide (∀ (i : Fin n), p i) = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_forall_eq_all | [43, 1] | [58, 16] | intro h | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h : (Fin.all fun i => decide (p i)) = false
i : Fin n
hi✝ : decide (p i) = false
hi : ¬p i
⊢ ¬∀ (i : Fin n), p i | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = false
i : Fin n
hi✝ : decide (p i) = false
hi : ¬p i
h : ∀ (i : Fin n), p i
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h : (Fin.all fun i => decide (p i)) = false
i : Fin n
hi✝ : decide (p i) = false
hi : ¬p i
⊢ ¬∀ (i : Fin n), p i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_forall_eq_all | [43, 1] | [58, 16] | apply hi | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = false
i : Fin n
hi✝ : decide (p i) = false
hi : ¬p i
h : ∀ (i : Fin n), p i
⊢ False | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = false
i : Fin n
hi✝ : decide (p i) = false
hi : ¬p i
h : ∀ (i : Fin n), p i
⊢ p i | Please generate a tactic in lean4 to solve the state.
STATE:
case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = false
i : Fin n
hi✝ : decide (p i) = false
hi : ¬p i
h : ∀ (i : Fin n), p i
⊢ False
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_forall_eq_all | [43, 1] | [58, 16] | exact h i | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = false
i : Fin n
hi✝ : decide (p i) = false
hi : ¬p i
h : ∀ (i : Fin n), p i
⊢ p i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∀ (i : Fin n), p i)
h✝ : (Fin.all fun i => decide (p i)) = false
i : Fin n
hi✝ : decide (p i) = false
hi : ¬p i
h : ∀ (i : Fin n), p i
⊢ p i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.any_zero | [63, 9] | [63, 85] | simp [Fin.any] | p : Fin 0 → Bool
⊢ Fin.any p = false | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
p : Fin 0 → Bool
⊢ Fin.any p = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.any_succ | [65, 1] | [66, 33] | simp [Fin.any, Fin.foldr_succ] | n : Nat
p : Fin (n + 1) → Bool
⊢ Fin.any p = (p 0 || Fin.any (p ∘ succ)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
⊢ Fin.any p = (p 0 || Fin.any (p ∘ succ))
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.exists_eq_true_of_any_eq_true | [68, 1] | [75, 55] | simp at h | x✝ : Fin 0 → Bool
h : Fin.any x✝ = true
⊢ ∃ i, x✝ i = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x✝ : Fin 0 → Bool
h : Fin.any x✝ = true
⊢ ∃ i, x✝ i = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.exists_eq_true_of_any_eq_true | [68, 1] | [75, 55] | rw [Fin.any, Fin.foldr_succ, Bool.or_eq_true] at h | n : Nat
p : Fin (n + 1) → Bool
h : Fin.any p = true
⊢ ∃ i, p i = true | n : Nat
p : Fin (n + 1) → Bool
h : p 0 = true ∨ foldr n (fun i v => p i.succ || v) false = true
⊢ ∃ i, p i = true | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h : Fin.any p = true
⊢ ∃ i, p i = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.exists_eq_true_of_any_eq_true | [68, 1] | [75, 55] | match h with
| .inl h => exists ⟨0, Nat.zero_lt_succ n⟩
| .inr h => match exists_eq_true_of_any_eq_true h with
| ⟨⟨i,hi⟩,hp⟩ => exists ⟨i+1, Nat.succ_lt_succ hi⟩ | n : Nat
p : Fin (n + 1) → Bool
h : p 0 = true ∨ foldr n (fun i v => p i.succ || v) false = true
⊢ ∃ i, p i = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h : p 0 = true ∨ foldr n (fun i v => p i.succ || v) false = true
⊢ ∃ i, p i = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.exists_eq_true_of_any_eq_true | [68, 1] | [75, 55] | exists ⟨0, Nat.zero_lt_succ n⟩ | n : Nat
p : Fin (n + 1) → Bool
h✝ : p 0 = true ∨ foldr n (fun i v => p i.succ || v) false = true
h : p 0 = true
⊢ ∃ i, p i = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h✝ : p 0 = true ∨ foldr n (fun i v => p i.succ || v) false = true
h : p 0 = true
⊢ ∃ i, p i = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.exists_eq_true_of_any_eq_true | [68, 1] | [75, 55] | match exists_eq_true_of_any_eq_true h with
| ⟨⟨i,hi⟩,hp⟩ => exists ⟨i+1, Nat.succ_lt_succ hi⟩ | n : Nat
p : Fin (n + 1) → Bool
h✝ : p 0 = true ∨ foldr n (fun i v => p i.succ || v) false = true
h : foldr n (fun i v => p i.succ || v) false = true
⊢ ∃ i, p i = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h✝ : p 0 = true ∨ foldr n (fun i v => p i.succ || v) false = true
h : foldr n (fun i v => p i.succ || v) false = true
⊢ ∃ i, p i = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.exists_eq_true_of_any_eq_true | [68, 1] | [75, 55] | exists ⟨i+1, Nat.succ_lt_succ hi⟩ | n : Nat
p : Fin (n + 1) → Bool
h✝ : p 0 = true ∨ foldr n (fun i v => p i.succ || v) false = true
h : foldr n (fun i v => p i.succ || v) false = true
i : Nat
hi : i < n
hp : p ⟨i, hi⟩.succ = true
⊢ ∃ i, p i = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h✝ : p 0 = true ∨ foldr n (fun i v => p i.succ || v) false = true
h : foldr n (fun i v => p i.succ || v) false = true
i : Nat
hi : i < n
hp : p ⟨i, hi⟩.succ = true
⊢ ∃ i, p i = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.forall_eq_false_of_any_eq_false | [77, 1] | [83, 79] | rw [Fin.any, Fin.foldr_succ, Bool.or_eq_false_iff] at h | n : Nat
p : Fin (n + 1) → Bool
h : Fin.any p = false
isLt✝ : 0 < n + 1
⊢ p ⟨0, isLt✝⟩ = false | n : Nat
p : Fin (n + 1) → Bool
h : p 0 = false ∧ foldr n (fun i v => p i.succ || v) false = false
isLt✝ : 0 < n + 1
⊢ p ⟨0, isLt✝⟩ = false | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h : Fin.any p = false
isLt✝ : 0 < n + 1
⊢ p ⟨0, isLt✝⟩ = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.forall_eq_false_of_any_eq_false | [77, 1] | [83, 79] | exact h.left | n : Nat
p : Fin (n + 1) → Bool
h : p 0 = false ∧ foldr n (fun i v => p i.succ || v) false = false
isLt✝ : 0 < n + 1
⊢ p ⟨0, isLt✝⟩ = false | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h : p 0 = false ∧ foldr n (fun i v => p i.succ || v) false = false
isLt✝ : 0 < n + 1
⊢ p ⟨0, isLt✝⟩ = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.forall_eq_false_of_any_eq_false | [77, 1] | [83, 79] | rw [Fin.any, Fin.foldr_succ, Bool.or_eq_false_iff] at h | n : Nat
p : Fin (n + 1) → Bool
h : Fin.any p = false
i : Nat
hi : i + 1 < n + 1
⊢ p ⟨i + 1, hi⟩ = false | n : Nat
p : Fin (n + 1) → Bool
h : p 0 = false ∧ foldr n (fun i v => p i.succ || v) false = false
i : Nat
hi : i + 1 < n + 1
⊢ p ⟨i + 1, hi⟩ = false | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h : Fin.any p = false
i : Nat
hi : i + 1 < n + 1
⊢ p ⟨i + 1, hi⟩ = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.forall_eq_false_of_any_eq_false | [77, 1] | [83, 79] | exact forall_eq_false_of_any_eq_false h.right ⟨i, Nat.lt_of_succ_lt_succ hi⟩ | n : Nat
p : Fin (n + 1) → Bool
h : p 0 = false ∧ foldr n (fun i v => p i.succ || v) false = false
i : Nat
hi : i + 1 < n + 1
⊢ p ⟨i + 1, hi⟩ = false | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin (n + 1) → Bool
h : p 0 = false ∧ foldr n (fun i v => p i.succ || v) false = false
i : Nat
hi : i + 1 < n + 1
⊢ p ⟨i + 1, hi⟩ = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_exists_eq_any | [96, 1] | [110, 14] | match h : Fin.any fun i => decide (p i) with
| true =>
match exists_eq_true_of_any_eq_true h with
| ⟨i, hi⟩ =>
have hi := of_decide_eq_true hi
apply decide_eq_true
exists i
| false =>
have h := forall_eq_false_of_any_eq_false h
apply decide_eq_false
intro ⟨i, hi⟩
absurd hi
apply of_decide_eq_f... | n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
⊢ decide (∃ i, p i) = Fin.any fun i => decide (p i) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
⊢ decide (∃ i, p i) = Fin.any fun i => decide (p i)
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_exists_eq_any | [96, 1] | [110, 14] | match exists_eq_true_of_any_eq_true h with
| ⟨i, hi⟩ =>
have hi := of_decide_eq_true hi
apply decide_eq_true
exists i | n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h : (Fin.any fun i => decide (p i)) = true
⊢ decide (∃ i, p i) = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h : (Fin.any fun i => decide (p i)) = true
⊢ decide (∃ i, p i) = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_exists_eq_any | [96, 1] | [110, 14] | have hi := of_decide_eq_true hi | n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h : (Fin.any fun i => decide (p i)) = true
i : Fin n
hi : decide (p i) = true
⊢ decide (∃ i, p i) = true | n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h : (Fin.any fun i => decide (p i)) = true
i : Fin n
hi✝ : decide (p i) = true
hi : p i
⊢ decide (∃ i, p i) = true | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h : (Fin.any fun i => decide (p i)) = true
i : Fin n
hi : decide (p i) = true
⊢ decide (∃ i, p i) = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_exists_eq_any | [96, 1] | [110, 14] | apply decide_eq_true | n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h : (Fin.any fun i => decide (p i)) = true
i : Fin n
hi✝ : decide (p i) = true
hi : p i
⊢ decide (∃ i, p i) = true | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h : (Fin.any fun i => decide (p i)) = true
i : Fin n
hi✝ : decide (p i) = true
hi : p i
⊢ ∃ i, p i | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h : (Fin.any fun i => decide (p i)) = true
i : Fin n
hi✝ : decide (p i) = true
hi : p i
⊢ decide (∃ i, p i) = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_exists_eq_any | [96, 1] | [110, 14] | exists i | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h : (Fin.any fun i => decide (p i)) = true
i : Fin n
hi✝ : decide (p i) = true
hi : p i
⊢ ∃ i, p i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h : (Fin.any fun i => decide (p i)) = true
i : Fin n
hi✝ : decide (p i) = true
hi : p i
⊢ ∃ i, p i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_exists_eq_any | [96, 1] | [110, 14] | have h := forall_eq_false_of_any_eq_false h | n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h : (Fin.any fun i => decide (p i)) = false
⊢ decide (∃ i, p i) = false | n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h✝ : (Fin.any fun i => decide (p i)) = false
h : ∀ (i : Fin n), decide (p i) = false
⊢ decide (∃ i, p i) = false | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h : (Fin.any fun i => decide (p i)) = false
⊢ decide (∃ i, p i) = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_exists_eq_any | [96, 1] | [110, 14] | apply decide_eq_false | n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h✝ : (Fin.any fun i => decide (p i)) = false
h : ∀ (i : Fin n), decide (p i) = false
⊢ decide (∃ i, p i) = false | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h✝ : (Fin.any fun i => decide (p i)) = false
h : ∀ (i : Fin n), decide (p i) = false
⊢ ¬∃ i, p i | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h✝ : (Fin.any fun i => decide (p i)) = false
h : ∀ (i : Fin n), decide (p i) = false
⊢ decide (∃ i, p i) = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_exists_eq_any | [96, 1] | [110, 14] | intro ⟨i, hi⟩ | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h✝ : (Fin.any fun i => decide (p i)) = false
h : ∀ (i : Fin n), decide (p i) = false
⊢ ¬∃ i, p i | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h✝ : (Fin.any fun i => decide (p i)) = false
h : ∀ (i : Fin n), decide (p i) = false
i : Fin n
hi : p i
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h✝ : (Fin.any fun i => decide (p i)) = false
h : ∀ (i : Fin n), decide (p i) = false
⊢ ¬∃ i, p i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_exists_eq_any | [96, 1] | [110, 14] | absurd hi | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h✝ : (Fin.any fun i => decide (p i)) = false
h : ∀ (i : Fin n), decide (p i) = false
i : Fin n
hi : p i
⊢ False | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h✝ : (Fin.any fun i => decide (p i)) = false
h : ∀ (i : Fin n), decide (p i) = false
i : Fin n
hi : p i
⊢ ¬p i | Please generate a tactic in lean4 to solve the state.
STATE:
case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h✝ : (Fin.any fun i => decide (p i)) = false
h : ∀ (i : Fin n), decide (p i) = false
i : Fin n
hi : p i
⊢ False
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_exists_eq_any | [96, 1] | [110, 14] | apply of_decide_eq_false | case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h✝ : (Fin.any fun i => decide (p i)) = false
h : ∀ (i : Fin n), decide (p i) = false
i : Fin n
hi : p i
⊢ ¬p i | case a.a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h✝ : (Fin.any fun i => decide (p i)) = false
h : ∀ (i : Fin n), decide (p i) = false
i : Fin n
hi : p i
⊢ decide (p i) = false | Please generate a tactic in lean4 to solve the state.
STATE:
case a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h✝ : (Fin.any fun i => decide (p i)) = false
h : ∀ (i : Fin n), decide (p i) = false
i : Fin n
hi : p i
⊢ ¬p i
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Fin/Basic.lean | Fin.decide_exists_eq_any | [96, 1] | [110, 14] | exact h i | case a.a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h✝ : (Fin.any fun i => decide (p i)) = false
h : ∀ (i : Fin n), decide (p i) = false
i : Fin n
hi : p i
⊢ decide (p i) = false | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.a
n : Nat
p : Fin n → Prop
inst✝¹ : DecidablePred p
inst✝ : Decidable (∃ i, p i)
h✝ : (Fin.any fun i => decide (p i)) = false
h : ∀ (i : Fin n), decide (p i) = false
i : Fin n
hi : p i
⊢ decide (p i) = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Basic.lean | List.Index.find_some | [76, 1] | [89, 22] | contradiction | case nil
α✝ : Type u_1
p : [].Index → Bool
i : [].Index
⊢ Index.find? p = some i → p i = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α✝ : Type u_1
p : [].Index → Bool
i : [].Index
⊢ Index.find? p = some i → p i = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Basic.lean | List.Index.find_some | [76, 1] | [89, 22] | intro heq | case cons
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
⊢ Index.find? p = some i → p i = true | case cons
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
heq : Index.find? p = some i
⊢ p i = true | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
⊢ Index.find? p = some i → p i = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Basic.lean | List.Index.find_some | [76, 1] | [89, 22] | simp only [Index.find?, h, cond] at heq | α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
heq : Index.find? p = some i
h : p head = true
⊢ p i = true | α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
h : p head = true
heq : some head = some i
⊢ p i = true | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
heq : Index.find? p = some i
h : p head = true
⊢ p i = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Basic.lean | List.Index.find_some | [76, 1] | [89, 22] | rw [←Option.some.inj heq, h] | α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
h : p head = true
heq : some head = some i
⊢ p i = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
h : p head = true
heq : some head = some i
⊢ p i = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Basic.lean | List.Index.find_some | [76, 1] | [89, 22] | simp only [Index.find?, h, cond, Option.map] at heq | α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
heq : Index.find? p = some i
h : p head = false
⊢ p i = true | α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
h : p head = false
heq :
(match Index.find? fun i => p i.tail with
| some x_1 => some x_1.tail
| none => none) =
some i
⊢ p i = true | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
heq : Index.find? p = some i
h : p head = false
⊢ p i = true
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Basic.lean | List.Index.find_some | [76, 1] | [89, 22] | split at heq | α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
h : p head = false
heq :
(match Index.find? fun i => p i.tail with
| some x_1 => some x_1.tail
| none => none) =
some i
⊢ p i = true | case h_1
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
h : p head = false
opt✝ : Option xs.Index
x✝ : xs.Index
heq✝ : (Index.find? fun i => p i.tail) = some x✝
heq : some x✝.tail = some i
⊢ p i = true
ca... | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
h : p head = false
heq :
(match Index.find? fun i => p i.tail with
| some x_1 => some x_1.t... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Basic.lean | List.Index.find_some | [76, 1] | [89, 22] | next h => rw [←Option.some.inj heq, ih _ h] | case h_1
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
h : p head = false
opt✝ : Option xs.Index
x✝ : xs.Index
heq✝ : (Index.find? fun i => p i.tail) = some x✝
heq : some x✝.tail = some i
⊢ p i = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h_1
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
h : p head = false
opt✝ : Option xs.Index
x✝ : xs.Index
heq✝ : (Index.find? fun i => p i... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Basic.lean | List.Index.find_some | [76, 1] | [89, 22] | rw [←Option.some.inj heq, ih _ h] | α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
h✝ : p head = false
opt✝ : Option xs.Index
x✝ : xs.Index
h : (Index.find? fun i => p i.tail) = some x✝
heq : some x✝.tail = some i
⊢ p i = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
h✝ : p head = false
opt✝ : Option xs.Index
x✝ : xs.Index
h : (Index.find? fun i => p i.tail) = so... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Basic.lean | List.Index.find_some | [76, 1] | [89, 22] | contradiction | case h_2
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
h : p head = false
opt✝ : Option xs.Index
heq✝ : (Index.find? fun i => p i.tail) = none
heq : none = some i
⊢ p i = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = some i → p i = true
p : (x :: xs).Index → Bool
i : (x :: xs).Index
h : p head = false
opt✝ : Option xs.Index
heq✝ : (Index.find? fun i => p i.tail) = none
... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Basic.lean | List.Index.find_none | [91, 1] | [103, 32] | cases i | case nil
α✝ : Type u_1
p : [].Index → Bool
i : [].Index
⊢ Index.find? p = none → p i = false | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α✝ : Type u_1
p : [].Index → Bool
i : [].Index
⊢ Index.find? p = none → p i = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Basic.lean | List.Index.find_none | [91, 1] | [103, 32] | intro heq | case cons
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = none → p i = false
p : (x :: xs).Index → Bool
i : (x :: xs).Index
⊢ Index.find? p = none → p i = false | case cons
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = none → p i = false
p : (x :: xs).Index → Bool
i : (x :: xs).Index
heq : Index.find? p = none
⊢ p i = false | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = none → p i = false
p : (x :: xs).Index → Bool
i : (x :: xs).Index
⊢ Index.find? p = none → p i = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Basic.lean | List.Index.find_none | [91, 1] | [103, 32] | simp only [Index.find?, cond, Option.map] at heq | case cons
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = none → p i = false
p : (x :: xs).Index → Bool
i : (x :: xs).Index
heq : Index.find? p = none
⊢ p i = false | case cons
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = none → p i = false
p : (x :: xs).Index → Bool
i : (x :: xs).Index
heq :
(match p head with
| true => some head
| false =>
match Index.find? fun i => p i.tail with
| some x_1 => some x_1.tail
... | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = none → p i = false
p : (x :: xs).Index → Bool
i : (x :: xs).Index
heq : Index.find? p = none
⊢ p i = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Basic.lean | List.Index.find_none | [91, 1] | [103, 32] | split at heq | case cons
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = none → p i = false
p : (x :: xs).Index → Bool
i : (x :: xs).Index
heq :
(match p head with
| true => some head
| false =>
match Index.find? fun i => p i.tail with
| some x_1 => some x_1.tail
... | case cons.h_1
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = none → p i = false
p : (x :: xs).Index → Bool
i : (x :: xs).Index
c✝ : Bool
heq✝ : p head = true
heq : some head = none
⊢ p i = false
case cons.h_2
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool}... | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = none → p i = false
p : (x :: xs).Index → Bool
i : (x :: xs).Index
heq :
(match p head with
| true => some head
| false =>
match Index.find... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Basic.lean | List.Index.find_none | [91, 1] | [103, 32] | contradiction | case cons.h_1
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = none → p i = false
p : (x :: xs).Index → Bool
i : (x :: xs).Index
c✝ : Bool
heq✝ : p head = true
heq : some head = none
⊢ p i = false | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.h_1
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = none → p i = false
p : (x :: xs).Index → Bool
i : (x :: xs).Index
c✝ : Bool
heq✝ : p head = true
heq : some head = none
⊢ p i = false
TACTIC:
|
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Basic.lean | List.Index.find_none | [91, 1] | [103, 32] | cases i | case cons.h_2
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = none → p i = false
p : (x :: xs).Index → Bool
i : (x :: xs).Index
c✝ : Bool
heq✝ : p head = false
heq :
(match Index.find? fun i => p i.tail with
| some x_1 => some x_1.tail
| none => none) =
none
... | case cons.h_2.head
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = none → p i = false
p : (x :: xs).Index → Bool
c✝ : Bool
heq✝ : p head = false
heq :
(match Index.find? fun i => p i.tail with
| some x_1 => some x_1.tail
| none => none) =
none
⊢ p head = fals... | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.h_2
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = none → p i = false
p : (x :: xs).Index → Bool
i : (x :: xs).Index
c✝ : Bool
heq✝ : p head = false
heq :
(match Index.find? fun i => p i.tail with
... |
https://github.com/fgdorais/extra4.git | eb1c6c30f5790bed1bb4b01534d271a2490d9730 | Extra/Index/Basic.lean | List.Index.find_none | [91, 1] | [103, 32] | assumption | case cons.h_2.head
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = none → p i = false
p : (x :: xs).Index → Bool
c✝ : Bool
heq✝ : p head = false
heq :
(match Index.find? fun i => p i.tail with
| some x_1 => some x_1.tail
| none => none) =
none
⊢ p head = fals... | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.h_2.head
α✝ : Type u_1
x : α✝
xs : List α✝
ih : ∀ {p : xs.Index → Bool} (i : xs.Index), Index.find? p = none → p i = false
p : (x :: xs).Index → Bool
c✝ : Bool
heq✝ : p head = false
heq :
(match Index.find? fun i => p i.tail with
| some x_1 =>... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.