Datasets:
pkuAI4M
/
lean_github

Dataset card Data Studio Files
xet
 Community
1
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/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.not_isInfix_intercalate_by_element
[1933, 1]
[1986, 19]
exact ein
case a.h α : Type u_1 l₁ delim : List α l₂ : List (List α) hlen : length l₁ ≤ 1 + length delim head mid : List α tail : List (List α) h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim hne_nil : head :: mid :: tail ≠ [] hl : l₂ = head :: mid :: tail contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim))) not_inf : ¬l₁ <:+: delim ++ head ++ delim hge : 1 ≤ length l₁ hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim) e : List α ein : e ∈ mid :: tail ⊢ e ∈ mid :: tail
no goals
Please generate a tactic in lean4 to solve the state. STATE: case a.h α : Type u_1 l₁ delim : List α l₂ : List (List α) hlen : length l₁ ≤ 1 + length delim head mid : List α tail : List (List α) h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim hne_nil : head :: mid :: tail ≠ [] hl : l₂ = head :: mid :: tail contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim))) not_inf : ¬l₁ <:+: delim ++ head ++ delim hge : 1 ≤ length l₁ hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim) e : List α ein : e ∈ mid :: tail ⊢ e ∈ mid :: tail TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.isInfix_length
[1989, 1]
[1994, 25]
have ⟨s,t, heq⟩ := h
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ ⊢ length l₁ ≤ length l₂
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ s t : List α heq : s ++ l₁ ++ t = l₂ ⊢ length l₁ ≤ length l₂
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ ⊢ length l₁ ≤ length l₂ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.isInfix_length
[1989, 1]
[1994, 25]
apply_fun @length α at heq
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ s t : List α heq : s ++ l₁ ++ t = l₂ ⊢ length l₁ ≤ length l₂
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ s t : List α heq : length (s ++ l₁ ++ t) = length l₂ ⊢ length l₁ ≤ length l₂
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ s t : List α heq : s ++ l₁ ++ t = l₂ ⊢ length l₁ ≤ length l₂ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.isInfix_length
[1989, 1]
[1994, 25]
rw [← heq]
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ s t : List α heq : length (s ++ l₁ ++ t) = length l₂ ⊢ length l₁ ≤ length l₂
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ s t : List α heq : length (s ++ l₁ ++ t) = length l₂ ⊢ length l₁ ≤ length (s ++ l₁ ++ t)
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ s t : List α heq : length (s ++ l₁ ++ t) = length l₂ ⊢ length l₁ ≤ length l₂ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.isInfix_length
[1989, 1]
[1994, 25]
rw [length_append, length_append, add_comm (length s), add_assoc]
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ s t : List α heq : length (s ++ l₁ ++ t) = length l₂ ⊢ length l₁ ≤ length (s ++ l₁ ++ t)
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ s t : List α heq : length (s ++ l₁ ++ t) = length l₂ ⊢ length l₁ ≤ length l₁ + (length s + length t)
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ s t : List α heq : length (s ++ l₁ ++ t) = length l₂ ⊢ length l₁ ≤ length (s ++ l₁ ++ t) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.isInfix_length
[1989, 1]
[1994, 25]
apply Nat.le_add_right
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ s t : List α heq : length (s ++ l₁ ++ t) = length l₂ ⊢ length l₁ ≤ length l₁ + (length s + length t)
no goals
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ s t : List α heq : length (s ++ l₁ ++ t) = length l₂ ⊢ length l₁ ≤ length l₁ + (length s + length t) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.eq_of_isInfix_len_ge
[1996, 1]
[2011, 37]
have ⟨s, t, heq⟩ := h
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ ⊢ l₁ = l₂
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ ⊢ l₁ = l₂
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ ⊢ l₁ = l₂ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.eq_of_isInfix_len_ge
[1996, 1]
[2011, 37]
have len_sum_eq := congr_arg length heq
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ ⊢ l₁ = l₂
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length (s ++ l₁ ++ t) = length l₂ ⊢ l₁ = l₂
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ ⊢ l₁ = l₂ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.eq_of_isInfix_len_ge
[1996, 1]
[2011, 37]
simp only [append_assoc, length_append] at len_sum_eq
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length (s ++ l₁ ++ t) = length l₂ ⊢ l₁ = l₂
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length s + (length l₁ + length t) = length l₂ ⊢ l₁ = l₂
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length (s ++ l₁ ++ t) = length l₂ ⊢ l₁ = l₂ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.eq_of_isInfix_len_ge
[1996, 1]
[2011, 37]
rw [add_comm (length l₁), add_comm, add_comm (length t), add_assoc] at len_sum_eq
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length s + (length l₁ + length t) = length l₂ ⊢ l₁ = l₂
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length l₁ + (length t + length s) = length l₂ ⊢ l₁ = l₂
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length s + (length l₁ + length t) = length l₂ ⊢ l₁ = l₂ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.eq_of_isInfix_len_ge
[1996, 1]
[2011, 37]
have len_eq : length l₁ = length l₂ := by apply ge_antisymm len_ge rw [← len_sum_eq] apply Nat.le_add_right
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length l₁ + (length t + length s) = length l₂ ⊢ l₁ = l₂
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length l₁ + (length t + length s) = length l₂ len_eq : length l₁ = length l₂ ⊢ l₁ = l₂
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length l₁ + (length t + length s) = length l₂ ⊢ l₁ = l₂ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.eq_of_isInfix_len_ge
[1996, 1]
[2011, 37]
rw [len_eq] at len_sum_eq
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length l₁ + (length t + length s) = length l₂ len_eq : length l₁ = length l₂ ⊢ l₁ = l₂
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length l₂ + (length t + length s) = length l₂ len_eq : length l₁ = length l₂ ⊢ l₁ = l₂
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length l₁ + (length t + length s) = length l₂ len_eq : length l₁ = length l₂ ⊢ l₁ = l₂ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.eq_of_isInfix_len_ge
[1996, 1]
[2011, 37]
simp only [add_right_eq_self, zero_le, ge_iff_le, nonpos_iff_eq_zero, add_eq_zero_iff] at len_sum_eq
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length l₂ + (length t + length s) = length l₂ len_eq : length l₁ = length l₂ ⊢ l₁ = l₂
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_eq : length l₁ = length l₂ len_sum_eq : length t = 0 ∧ length s = 0 ⊢ l₁ = l₂
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length l₂ + (length t + length s) = length l₂ len_eq : length l₁ = length l₂ ⊢ l₁ = l₂ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.eq_of_isInfix_len_ge
[1996, 1]
[2011, 37]
have ⟨teq, seq⟩ := len_sum_eq
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_eq : length l₁ = length l₂ len_sum_eq : length t = 0 ∧ length s = 0 ⊢ l₁ = l₂
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_eq : length l₁ = length l₂ len_sum_eq : length t = 0 ∧ length s = 0 teq : length t = 0 seq : length s = 0 ⊢ l₁ = l₂
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_eq : length l₁ = length l₂ len_sum_eq : length t = 0 ∧ length s = 0 ⊢ l₁ = l₂ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.eq_of_isInfix_len_ge
[1996, 1]
[2011, 37]
rw [List.length_eq_zero] at seq
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_eq : length l₁ = length l₂ len_sum_eq : length t = 0 ∧ length s = 0 teq : length t = 0 seq : length s = 0 ⊢ l₁ = l₂
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_eq : length l₁ = length l₂ len_sum_eq : length t = 0 ∧ length s = 0 teq : length t = 0 seq : s = [] ⊢ l₁ = l₂
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_eq : length l₁ = length l₂ len_sum_eq : length t = 0 ∧ length s = 0 teq : length t = 0 seq : length s = 0 ⊢ l₁ = l₂ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.eq_of_isInfix_len_ge
[1996, 1]
[2011, 37]
rw [List.length_eq_zero] at teq
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_eq : length l₁ = length l₂ len_sum_eq : length t = 0 ∧ length s = 0 teq : length t = 0 seq : s = [] ⊢ l₁ = l₂
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_eq : length l₁ = length l₂ len_sum_eq : length t = 0 ∧ length s = 0 teq : t = [] seq : s = [] ⊢ l₁ = l₂
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_eq : length l₁ = length l₂ len_sum_eq : length t = 0 ∧ length s = 0 teq : length t = 0 seq : s = [] ⊢ l₁ = l₂ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.eq_of_isInfix_len_ge
[1996, 1]
[2011, 37]
subst_vars
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_eq : length l₁ = length l₂ len_sum_eq : length t = 0 ∧ length s = 0 teq : t = [] seq : s = [] ⊢ l₁ = l₂
α : Type u_1 l₁ : List α len_sum_eq : length [] = 0 ∧ length [] = 0 h : l₁ <:+: [] ++ l₁ ++ [] len_ge : length l₁ ≥ length ([] ++ l₁ ++ []) len_eq : length l₁ = length ([] ++ l₁ ++ []) ⊢ l₁ = [] ++ l₁ ++ []
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_eq : length l₁ = length l₂ len_sum_eq : length t = 0 ∧ length s = 0 teq : t = [] seq : s = [] ⊢ l₁ = l₂ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.eq_of_isInfix_len_ge
[1996, 1]
[2011, 37]
simp only [append_nil, nil_append]
α : Type u_1 l₁ : List α len_sum_eq : length [] = 0 ∧ length [] = 0 h : l₁ <:+: [] ++ l₁ ++ [] len_ge : length l₁ ≥ length ([] ++ l₁ ++ []) len_eq : length l₁ = length ([] ++ l₁ ++ []) ⊢ l₁ = [] ++ l₁ ++ []
no goals
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ : List α len_sum_eq : length [] = 0 ∧ length [] = 0 h : l₁ <:+: [] ++ l₁ ++ [] len_ge : length l₁ ≥ length ([] ++ l₁ ++ []) len_eq : length l₁ = length ([] ++ l₁ ++ []) ⊢ l₁ = [] ++ l₁ ++ [] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.eq_of_isInfix_len_ge
[1996, 1]
[2011, 37]
apply ge_antisymm len_ge
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length l₁ + (length t + length s) = length l₂ ⊢ length l₁ = length l₂
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length l₁ + (length t + length s) = length l₂ ⊢ length l₁ ≤ length l₂
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length l₁ + (length t + length s) = length l₂ ⊢ length l₁ = length l₂ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.eq_of_isInfix_len_ge
[1996, 1]
[2011, 37]
rw [← len_sum_eq]
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length l₁ + (length t + length s) = length l₂ ⊢ length l₁ ≤ length l₂
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length l₁ + (length t + length s) = length l₂ ⊢ length l₁ ≤ length l₁ + (length t + length s)
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length l₁ + (length t + length s) = length l₂ ⊢ length l₁ ≤ length l₂ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.eq_of_isInfix_len_ge
[1996, 1]
[2011, 37]
apply Nat.le_add_right
α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length l₁ + (length t + length s) = length l₂ ⊢ length l₁ ≤ length l₁ + (length t + length s)
no goals
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 l₁ l₂ : List α h : l₁ <:+: l₂ len_ge : length l₁ ≥ length l₂ s t : List α heq : s ++ l₁ ++ t = l₂ len_sum_eq : length l₁ + (length t + length s) = length l₂ ⊢ length l₁ ≤ length l₁ + (length t + length s) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse
[2013, 1]
[2029, 32]
match l with | [] => rw [intersperse] at h; contradiction | [single] => simp only [intersperse, mem_singleton] at h right simp only [h, mem_singleton] | head::mid::tail => simp only [intersperse, mem_cons] at h simp only [mem_cons] rcases h with hd | sp | mem . simp only [hd, true_or, or_true] . simp only [sp, true_or] . rcases mem_intersperse mem with mid | tl . simp only [mid, true_or] . simp only [mem_cons] at tl simp only [tl, or_true]
α✝ : Type u_1 a sep : α✝ l : List α✝ h : a ∈ intersperse sep l ⊢ a = sep ∨ a ∈ l
no goals
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a sep : α✝ l : List α✝ h : a ∈ intersperse sep l ⊢ a = sep ∨ a ∈ l TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse
[2013, 1]
[2029, 32]
rw [intersperse] at h
α✝ : Type u_1 a sep : α✝ l : List α✝ h : a ∈ intersperse sep [] ⊢ a = sep ∨ a ∈ []
α✝ : Type u_1 a sep : α✝ l : List α✝ h : a ∈ [] ⊢ a = sep ∨ a ∈ []
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a sep : α✝ l : List α✝ h : a ∈ intersperse sep [] ⊢ a = sep ∨ a ∈ [] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse
[2013, 1]
[2029, 32]
contradiction
α✝ : Type u_1 a sep : α✝ l : List α✝ h : a ∈ [] ⊢ a = sep ∨ a ∈ []
no goals
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a sep : α✝ l : List α✝ h : a ∈ [] ⊢ a = sep ∨ a ∈ [] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse
[2013, 1]
[2029, 32]
simp only [intersperse, mem_singleton] at h
α✝ : Type u_1 a sep : α✝ l : List α✝ single : α✝ h : a ∈ intersperse sep [single] ⊢ a = sep ∨ a ∈ [single]
α✝ : Type u_1 a sep : α✝ l : List α✝ single : α✝ h : a = single ⊢ a = sep ∨ a ∈ [single]
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a sep : α✝ l : List α✝ single : α✝ h : a ∈ intersperse sep [single] ⊢ a = sep ∨ a ∈ [single] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse
[2013, 1]
[2029, 32]
right
α✝ : Type u_1 a sep : α✝ l : List α✝ single : α✝ h : a = single ⊢ a = sep ∨ a ∈ [single]
case h α✝ : Type u_1 a sep : α✝ l : List α✝ single : α✝ h : a = single ⊢ a ∈ [single]
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a sep : α✝ l : List α✝ single : α✝ h : a = single ⊢ a = sep ∨ a ∈ [single] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse
[2013, 1]
[2029, 32]
simp only [h, mem_singleton]
case h α✝ : Type u_1 a sep : α✝ l : List α✝ single : α✝ h : a = single ⊢ a ∈ [single]
no goals
Please generate a tactic in lean4 to solve the state. STATE: case h α✝ : Type u_1 a sep : α✝ l : List α✝ single : α✝ h : a = single ⊢ a ∈ [single] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse
[2013, 1]
[2029, 32]
simp only [intersperse, mem_cons] at h
α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ h : a ∈ intersperse sep (head :: mid :: tail) ⊢ a = sep ∨ a ∈ head :: mid :: tail
α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ h : a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail) ⊢ a = sep ∨ a ∈ head :: mid :: tail
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ h : a ∈ intersperse sep (head :: mid :: tail) ⊢ a = sep ∨ a ∈ head :: mid :: tail TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse
[2013, 1]
[2029, 32]
simp only [mem_cons]
α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ h : a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail) ⊢ a = sep ∨ a ∈ head :: mid :: tail
α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ h : a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail) ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ h : a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail) ⊢ a = sep ∨ a ∈ head :: mid :: tail TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse
[2013, 1]
[2029, 32]
rcases h with hd | sp | mem
α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ h : a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail) ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail
case inl α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ hd : a = head ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail case inr.inl α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ sp : a = sep ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail case inr.inr α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ mem : a ∈ intersperse sep (mid :: tail) ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ h : a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail) ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse
[2013, 1]
[2029, 32]
. simp only [hd, true_or, or_true]
case inl α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ hd : a = head ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail case inr.inl α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ sp : a = sep ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail case inr.inr α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ mem : a ∈ intersperse sep (mid :: tail) ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail
case inr.inl α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ sp : a = sep ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail case inr.inr α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ mem : a ∈ intersperse sep (mid :: tail) ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail
Please generate a tactic in lean4 to solve the state. STATE: case inl α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ hd : a = head ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail case inr.inl α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ sp : a = sep ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail case inr.inr α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ mem : a ∈ intersperse sep (mid :: tail) ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse
[2013, 1]
[2029, 32]
. simp only [sp, true_or]
case inr.inl α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ sp : a = sep ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail case inr.inr α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ mem : a ∈ intersperse sep (mid :: tail) ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail
case inr.inr α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ mem : a ∈ intersperse sep (mid :: tail) ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail
Please generate a tactic in lean4 to solve the state. STATE: case inr.inl α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ sp : a = sep ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail case inr.inr α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ mem : a ∈ intersperse sep (mid :: tail) ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse
[2013, 1]
[2029, 32]
. rcases mem_intersperse mem with mid | tl . simp only [mid, true_or] . simp only [mem_cons] at tl simp only [tl, or_true]
case inr.inr α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ mem : a ∈ intersperse sep (mid :: tail) ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail
no goals
Please generate a tactic in lean4 to solve the state. STATE: case inr.inr α✝ : Type u_1 a sep : α✝ l : List α✝ head mid : α✝ tail : List α✝ mem : a ∈ intersperse sep (mid :: tail) ⊢ a = sep ∨ a = head ∨ a = mid ∨ a ∈ tail TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse_of_mem
[2031, 1]
[2040, 83]
match l with | [] => simp only [not_mem_nil] at h | [a] => simp_all only [mem_singleton, intersperse] | head::mid::tail => simp only [intersperse, mem_cons] simp at h rcases h with h |m |t <;> simp_all . right; right; apply mem_intersperse_of_mem; simp only [mem_cons, true_or] . right; right; apply mem_intersperse_of_mem; simp only [t, mem_cons, or_true]
α✝ : Type u_1 a : α✝ l : List α✝ sep : α✝ h : a ∈ l ⊢ a ∈ intersperse sep l
no goals
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a : α✝ l : List α✝ sep : α✝ h : a ∈ l ⊢ a ∈ intersperse sep l TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse_of_mem
[2031, 1]
[2040, 83]
simp only [not_mem_nil] at h
α✝ : Type u_1 a : α✝ l : List α✝ sep : α✝ h : a ∈ [] ⊢ a ∈ intersperse sep []
no goals
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a : α✝ l : List α✝ sep : α✝ h : a ∈ [] ⊢ a ∈ intersperse sep [] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse_of_mem
[2031, 1]
[2040, 83]
simp_all only [mem_singleton, intersperse]
α✝ : Type u_1 a✝ : α✝ l : List α✝ sep a : α✝ h : a✝ ∈ [a] ⊢ a✝ ∈ intersperse sep [a]
no goals
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a✝ : α✝ l : List α✝ sep a : α✝ h : a✝ ∈ [a] ⊢ a✝ ∈ intersperse sep [a] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse_of_mem
[2031, 1]
[2040, 83]
simp only [intersperse, mem_cons]
α✝ : Type u_1 a : α✝ l : List α✝ sep head mid : α✝ tail : List α✝ h : a ∈ head :: mid :: tail ⊢ a ∈ intersperse sep (head :: mid :: tail)
α✝ : Type u_1 a : α✝ l : List α✝ sep head mid : α✝ tail : List α✝ h : a ∈ head :: mid :: tail ⊢ a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail)
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a : α✝ l : List α✝ sep head mid : α✝ tail : List α✝ h : a ∈ head :: mid :: tail ⊢ a ∈ intersperse sep (head :: mid :: tail) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse_of_mem
[2031, 1]
[2040, 83]
simp at h
α✝ : Type u_1 a : α✝ l : List α✝ sep head mid : α✝ tail : List α✝ h : a ∈ head :: mid :: tail ⊢ a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail)
α✝ : Type u_1 a : α✝ l : List α✝ sep head mid : α✝ tail : List α✝ h : a = head ∨ a = mid ∨ a ∈ tail ⊢ a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail)
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a : α✝ l : List α✝ sep head mid : α✝ tail : List α✝ h : a ∈ head :: mid :: tail ⊢ a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse_of_mem
[2031, 1]
[2040, 83]
rcases h with h |m |t <;> simp_all
α✝ : Type u_1 a : α✝ l : List α✝ sep head mid : α✝ tail : List α✝ h : a = head ∨ a = mid ∨ a ∈ tail ⊢ a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail)
case inr.inl α✝ : Type u_1 a : α✝ l : List α✝ sep head mid : α✝ tail : List α✝ m : a = mid ⊢ mid = head ∨ mid = sep ∨ mid ∈ intersperse sep (mid :: tail) case inr.inr α✝ : Type u_1 a : α✝ l : List α✝ sep head mid : α✝ tail : List α✝ t : a ∈ tail ⊢ a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail)
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a : α✝ l : List α✝ sep head mid : α✝ tail : List α✝ h : a = head ∨ a = mid ∨ a ∈ tail ⊢ a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse_of_mem
[2031, 1]
[2040, 83]
. right; right; apply mem_intersperse_of_mem; simp only [mem_cons, true_or]
case inr.inl α✝ : Type u_1 a : α✝ l : List α✝ sep head mid : α✝ tail : List α✝ m : a = mid ⊢ mid = head ∨ mid = sep ∨ mid ∈ intersperse sep (mid :: tail) case inr.inr α✝ : Type u_1 a : α✝ l : List α✝ sep head mid : α✝ tail : List α✝ t : a ∈ tail ⊢ a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail)
case inr.inr α✝ : Type u_1 a : α✝ l : List α✝ sep head mid : α✝ tail : List α✝ t : a ∈ tail ⊢ a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail)
Please generate a tactic in lean4 to solve the state. STATE: case inr.inl α✝ : Type u_1 a : α✝ l : List α✝ sep head mid : α✝ tail : List α✝ m : a = mid ⊢ mid = head ∨ mid = sep ∨ mid ∈ intersperse sep (mid :: tail) case inr.inr α✝ : Type u_1 a : α✝ l : List α✝ sep head mid : α✝ tail : List α✝ t : a ∈ tail ⊢ a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intersperse_of_mem
[2031, 1]
[2040, 83]
. right; right; apply mem_intersperse_of_mem; simp only [t, mem_cons, or_true]
case inr.inr α✝ : Type u_1 a : α✝ l : List α✝ sep head mid : α✝ tail : List α✝ t : a ∈ tail ⊢ a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail)
no goals
Please generate a tactic in lean4 to solve the state. STATE: case inr.inr α✝ : Type u_1 a : α✝ l : List α✝ sep head mid : α✝ tail : List α✝ t : a ∈ tail ⊢ a = head ∨ a = sep ∨ a ∈ intersperse sep (mid :: tail) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intercalate
[2044, 1]
[2052, 13]
simp only [intercalate, mem_join] at h
α✝ : Type u_1 a : α✝ delim : List α✝ l : List (List α✝) h : a ∈ intercalate delim l ⊢ a ∈ delim ∨ ∃ e, e ∈ l ∧ a ∈ e
α✝ : Type u_1 a : α✝ delim : List α✝ l : List (List α✝) h : ∃ l_1, l_1 ∈ intersperse delim l ∧ a ∈ l_1 ⊢ a ∈ delim ∨ ∃ e, e ∈ l ∧ a ∈ e
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a : α✝ delim : List α✝ l : List (List α✝) h : a ∈ intercalate delim l ⊢ a ∈ delim ∨ ∃ e, e ∈ l ∧ a ∈ e TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intercalate
[2044, 1]
[2052, 13]
have ⟨e, ein, ain⟩ := h
α✝ : Type u_1 a : α✝ delim : List α✝ l : List (List α✝) h : ∃ l_1, l_1 ∈ intersperse delim l ∧ a ∈ l_1 ⊢ a ∈ delim ∨ ∃ e, e ∈ l ∧ a ∈ e
α✝ : Type u_1 a : α✝ delim : List α✝ l : List (List α✝) h : ∃ l_1, l_1 ∈ intersperse delim l ∧ a ∈ l_1 e : List α✝ ein : e ∈ intersperse delim l ain : a ∈ e ⊢ a ∈ delim ∨ ∃ e, e ∈ l ∧ a ∈ e
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a : α✝ delim : List α✝ l : List (List α✝) h : ∃ l_1, l_1 ∈ intersperse delim l ∧ a ∈ l_1 ⊢ a ∈ delim ∨ ∃ e, e ∈ l ∧ a ∈ e TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intercalate
[2044, 1]
[2052, 13]
cases List.mem_intersperse ein with | inl heq => simp only [← heq, ain, true_or] | inr heq => right exists e
α✝ : Type u_1 a : α✝ delim : List α✝ l : List (List α✝) h : ∃ l_1, l_1 ∈ intersperse delim l ∧ a ∈ l_1 e : List α✝ ein : e ∈ intersperse delim l ain : a ∈ e ⊢ a ∈ delim ∨ ∃ e, e ∈ l ∧ a ∈ e
no goals
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a : α✝ delim : List α✝ l : List (List α✝) h : ∃ l_1, l_1 ∈ intersperse delim l ∧ a ∈ l_1 e : List α✝ ein : e ∈ intersperse delim l ain : a ∈ e ⊢ a ∈ delim ∨ ∃ e, e ∈ l ∧ a ∈ e TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intercalate
[2044, 1]
[2052, 13]
simp only [← heq, ain, true_or]
case inl α✝ : Type u_1 a : α✝ delim : List α✝ l : List (List α✝) h : ∃ l_1, l_1 ∈ intersperse delim l ∧ a ∈ l_1 e : List α✝ ein : e ∈ intersperse delim l ain : a ∈ e heq : e = delim ⊢ a ∈ delim ∨ ∃ e, e ∈ l ∧ a ∈ e
no goals
Please generate a tactic in lean4 to solve the state. STATE: case inl α✝ : Type u_1 a : α✝ delim : List α✝ l : List (List α✝) h : ∃ l_1, l_1 ∈ intersperse delim l ∧ a ∈ l_1 e : List α✝ ein : e ∈ intersperse delim l ain : a ∈ e heq : e = delim ⊢ a ∈ delim ∨ ∃ e, e ∈ l ∧ a ∈ e TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intercalate
[2044, 1]
[2052, 13]
right
case inr α✝ : Type u_1 a : α✝ delim : List α✝ l : List (List α✝) h : ∃ l_1, l_1 ∈ intersperse delim l ∧ a ∈ l_1 e : List α✝ ein : e ∈ intersperse delim l ain : a ∈ e heq : e ∈ l ⊢ a ∈ delim ∨ ∃ e, e ∈ l ∧ a ∈ e
case inr.h α✝ : Type u_1 a : α✝ delim : List α✝ l : List (List α✝) h : ∃ l_1, l_1 ∈ intersperse delim l ∧ a ∈ l_1 e : List α✝ ein : e ∈ intersperse delim l ain : a ∈ e heq : e ∈ l ⊢ ∃ e, e ∈ l ∧ a ∈ e
Please generate a tactic in lean4 to solve the state. STATE: case inr α✝ : Type u_1 a : α✝ delim : List α✝ l : List (List α✝) h : ∃ l_1, l_1 ∈ intersperse delim l ∧ a ∈ l_1 e : List α✝ ein : e ∈ intersperse delim l ain : a ∈ e heq : e ∈ l ⊢ a ∈ delim ∨ ∃ e, e ∈ l ∧ a ∈ e TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intercalate
[2044, 1]
[2052, 13]
exists e
case inr.h α✝ : Type u_1 a : α✝ delim : List α✝ l : List (List α✝) h : ∃ l_1, l_1 ∈ intersperse delim l ∧ a ∈ l_1 e : List α✝ ein : e ∈ intersperse delim l ain : a ∈ e heq : e ∈ l ⊢ ∃ e, e ∈ l ∧ a ∈ e
no goals
Please generate a tactic in lean4 to solve the state. STATE: case inr.h α✝ : Type u_1 a : α✝ delim : List α✝ l : List (List α✝) h : ∃ l_1, l_1 ∈ intersperse delim l ∧ a ∈ l_1 e : List α✝ ein : e ∈ intersperse delim l ain : a ∈ e heq : e ∈ l ⊢ ∃ e, e ∈ l ∧ a ∈ e TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intercalate_of_mem
[2054, 1]
[2059, 11]
rw [intercalate]
α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ a ∈ intercalate delim l
α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ a ∈ join (intersperse delim l)
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ a ∈ intercalate delim l TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intercalate_of_mem
[2054, 1]
[2059, 11]
apply mem_join_of_mem
α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ a ∈ join (intersperse delim l)
case lL α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ ?l ∈ intersperse delim l case al α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ a ∈ ?l case l α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ List α✝
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ a ∈ join (intersperse delim l) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intercalate_of_mem
[2054, 1]
[2059, 11]
apply mem_intersperse_of_mem
case lL α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ ?l ∈ intersperse delim l case al α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ a ∈ ?l case l α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ List α✝
case lL.h α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ ?l ∈ l case al α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ a ∈ ?l case l α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ List α✝
Please generate a tactic in lean4 to solve the state. STATE: case lL α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ ?l ∈ intersperse delim l case al α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ a ∈ ?l case l α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ List α✝ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intercalate_of_mem
[2054, 1]
[2059, 11]
apply h₂
case lL.h α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ ?l ∈ l case al α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ a ∈ ?l case l α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ List α✝
case al α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ a ∈ e
Please generate a tactic in lean4 to solve the state. STATE: case lL.h α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ ?l ∈ l case al α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ a ∈ ?l case l α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ List α✝ TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_intercalate_of_mem
[2054, 1]
[2059, 11]
apply h₁
case al α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ a ∈ e
no goals
Please generate a tactic in lean4 to solve the state. STATE: case al α✝ : Type u_1 a : α✝ e : List α✝ l : List (List α✝) delim : List α✝ h₁ : a ∈ e h₂ : e ∈ l ⊢ a ∈ e TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.join_eq_nil
[2061, 1]
[2067, 13]
induction l with | nil => simp only [not_mem_nil, IsEmpty.forall_iff, forall_const] | cons head tail ih=> simp_all only [join, append_eq_nil, mem_cons, forall_eq_or_imp, true_and, forall_true_left] apply ih
α✝ : Type u_1 l : List (List α✝) h : join l = [] ⊢ ∀ (e : List α✝), e ∈ l → e = []
no goals
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 l : List (List α✝) h : join l = [] ⊢ ∀ (e : List α✝), e ∈ l → e = [] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.join_eq_nil
[2061, 1]
[2067, 13]
simp only [not_mem_nil, IsEmpty.forall_iff, forall_const]
case nil α✝ : Type u_1 h : join [] = [] ⊢ ∀ (e : List α✝), e ∈ [] → e = []
no goals
Please generate a tactic in lean4 to solve the state. STATE: case nil α✝ : Type u_1 h : join [] = [] ⊢ ∀ (e : List α✝), e ∈ [] → e = [] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.join_eq_nil
[2061, 1]
[2067, 13]
simp_all only [join, append_eq_nil, mem_cons, forall_eq_or_imp, true_and, forall_true_left]
case cons α✝ : Type u_1 head : List α✝ tail : List (List α✝) ih : join tail = [] → ∀ (e : List α✝), e ∈ tail → e = [] h : join (head :: tail) = [] ⊢ ∀ (e : List α✝), e ∈ head :: tail → e = []
case cons α✝ : Type u_1 head : List α✝ tail : List (List α✝) ih : ∀ (e : List α✝), e ∈ tail → e = [] h : head = [] ∧ join tail = [] ⊢ ∀ (a : List α✝), a ∈ tail → a = []
Please generate a tactic in lean4 to solve the state. STATE: case cons α✝ : Type u_1 head : List α✝ tail : List (List α✝) ih : join tail = [] → ∀ (e : List α✝), e ∈ tail → e = [] h : join (head :: tail) = [] ⊢ ∀ (e : List α✝), e ∈ head :: tail → e = [] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.join_eq_nil
[2061, 1]
[2067, 13]
apply ih
case cons α✝ : Type u_1 head : List α✝ tail : List (List α✝) ih : ∀ (e : List α✝), e ∈ tail → e = [] h : head = [] ∧ join tail = [] ⊢ ∀ (a : List α✝), a ∈ tail → a = []
no goals
Please generate a tactic in lean4 to solve the state. STATE: case cons α✝ : Type u_1 head : List α✝ tail : List (List α✝) ih : ∀ (e : List α✝), e ∈ tail → e = [] h : head = [] ∧ join tail = [] ⊢ ∀ (a : List α✝), a ∈ tail → a = [] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.intercalate_eq_nil
[2069, 1]
[2074, 35]
rw [intercalate] at h
α✝ : Type u_1 delim : List α✝ l : List (List α✝) h : intercalate delim l = [] ⊢ ∀ (e : List α✝), e ∈ l → e = []
α✝ : Type u_1 delim : List α✝ l : List (List α✝) h : join (intersperse delim l) = [] ⊢ ∀ (e : List α✝), e ∈ l → e = []
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 delim : List α✝ l : List (List α✝) h : intercalate delim l = [] ⊢ ∀ (e : List α✝), e ∈ l → e = [] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.intercalate_eq_nil
[2069, 1]
[2074, 35]
have all_nil := join_eq_nil h
α✝ : Type u_1 delim : List α✝ l : List (List α✝) h : join (intersperse delim l) = [] ⊢ ∀ (e : List α✝), e ∈ l → e = []
α✝ : Type u_1 delim : List α✝ l : List (List α✝) h : join (intersperse delim l) = [] all_nil : ∀ (e : List α✝), e ∈ intersperse delim l → e = [] ⊢ ∀ (e : List α✝), e ∈ l → e = []
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 delim : List α✝ l : List (List α✝) h : join (intersperse delim l) = [] ⊢ ∀ (e : List α✝), e ∈ l → e = [] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.intercalate_eq_nil
[2069, 1]
[2074, 35]
intro e ein
α✝ : Type u_1 delim : List α✝ l : List (List α✝) h : join (intersperse delim l) = [] all_nil : ∀ (e : List α✝), e ∈ intersperse delim l → e = [] ⊢ ∀ (e : List α✝), e ∈ l → e = []
α✝ : Type u_1 delim : List α✝ l : List (List α✝) h : join (intersperse delim l) = [] all_nil : ∀ (e : List α✝), e ∈ intersperse delim l → e = [] e : List α✝ ein : e ∈ l ⊢ e = []
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 delim : List α✝ l : List (List α✝) h : join (intersperse delim l) = [] all_nil : ∀ (e : List α✝), e ∈ intersperse delim l → e = [] ⊢ ∀ (e : List α✝), e ∈ l → e = [] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.intercalate_eq_nil
[2069, 1]
[2074, 35]
apply all_nil
α✝ : Type u_1 delim : List α✝ l : List (List α✝) h : join (intersperse delim l) = [] all_nil : ∀ (e : List α✝), e ∈ intersperse delim l → e = [] e : List α✝ ein : e ∈ l ⊢ e = []
case a α✝ : Type u_1 delim : List α✝ l : List (List α✝) h : join (intersperse delim l) = [] all_nil : ∀ (e : List α✝), e ∈ intersperse delim l → e = [] e : List α✝ ein : e ∈ l ⊢ e ∈ intersperse delim l
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 delim : List α✝ l : List (List α✝) h : join (intersperse delim l) = [] all_nil : ∀ (e : List α✝), e ∈ intersperse delim l → e = [] e : List α✝ ein : e ∈ l ⊢ e = [] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.intercalate_eq_nil
[2069, 1]
[2074, 35]
apply mem_intersperse_of_mem ein
case a α✝ : Type u_1 delim : List α✝ l : List (List α✝) h : join (intersperse delim l) = [] all_nil : ∀ (e : List α✝), e ∈ intersperse delim l → e = [] e : List α✝ ein : e ∈ l ⊢ e ∈ intersperse delim l
no goals
Please generate a tactic in lean4 to solve the state. STATE: case a α✝ : Type u_1 delim : List α✝ l : List (List α✝) h : join (intersperse delim l) = [] all_nil : ∀ (e : List α✝), e ∈ intersperse delim l → e = [] e : List α✝ ein : e ∈ l ⊢ e ∈ intersperse delim l TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
intro contr
α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] ⊢ l ≠ []
α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : l = [] ⊢ False
Please generate a tactic in lean4 to solve the state. STATE: α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] ⊢ l ≠ [] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
apply h₂
α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : l = [] ⊢ False
α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : l = [] ⊢ intercalate delim l = []
Please generate a tactic in lean4 to solve the state. STATE: α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : l = [] ⊢ False TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
rw [contr]
α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : l = [] ⊢ intercalate delim l = []
α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : l = [] ⊢ intercalate delim [] = []
Please generate a tactic in lean4 to solve the state. STATE: α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : l = [] ⊢ intercalate delim l = [] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
simp only [intercalate._eq_1, join]
α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : l = [] ⊢ intercalate delim [] = []
no goals
Please generate a tactic in lean4 to solve the state. STATE: α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : l = [] ⊢ intercalate delim [] = [] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
intro contr
α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] ⊢ getLast l (_ : l = [] → False) ≠ []
α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : getLast l (_ : l = [] → False) = [] ⊢ False
Please generate a tactic in lean4 to solve the state. STATE: α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] ⊢ getLast l (_ : l = [] → False) ≠ [] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
apply not_nil
α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : getLast l (_ : l = [] → False) = [] ⊢ False
α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : getLast l (_ : l = [] → False) = [] ⊢ getLast? l = some []
Please generate a tactic in lean4 to solve the state. STATE: α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : getLast l (_ : l = [] → False) = [] ⊢ False TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
rw[←contr]
α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : getLast l (_ : l = [] → False) = [] ⊢ getLast? l = some []
α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : getLast l (_ : l = [] → False) = [] ⊢ getLast? l = some (getLast l (_ : l = [] → False))
Please generate a tactic in lean4 to solve the state. STATE: α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : getLast l (_ : l = [] → False) = [] ⊢ getLast? l = some [] TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
apply List.getLast?_eq_getLast
α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : getLast l (_ : l = [] → False) = [] ⊢ getLast? l = some (getLast l (_ : l = [] → False))
no goals
Please generate a tactic in lean4 to solve the state. STATE: α : Type ?u.383648 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] contr : getLast l (_ : l = [] → False) = [] ⊢ getLast? l = some (getLast l (_ : l = [] → False)) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
match l with | [] => simp only [intercalate._eq_1, join, ne_eq, not_true] at h₂ | [a] => simp [intercalate] | [a,b] => simp [intercalate] simp [← intercalate._eq_1] simp only [← append_assoc] rw [getLast_append'] | head::mid::mid₂::tail => simp [intercalate] simp [← intercalate._eq_1] simp only [← append_assoc] rw [getLast_append', getLast_intercalate (mid₂::tail)] . intro contr apply not_nil rw [List.getLast?_eq_getLast] simp only [ne_eq, not_false_iff, getLast_cons, Option.some.injEq] generalize_proofs hp apply List.intercalate_eq_nil contr (getLast (mid₂ :: tail) hp) apply List.getLast_mem simp only [ne_eq, not_false_iff] . intro contr apply not_nil simp only [getLast?_cons_cons, contr] . exact a
α : Type u_1 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] ⊢ getLast (intercalate delim l) h₂ = getLast (getLast l (_ : l = [] → False)) (_ : getLast l (_ : l = [] → False) = [] → False)
no goals
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 delim : List α a : α l : List (List α) h₂ : intercalate delim l ≠ [] not_nil : getLast? l ≠ some [] ⊢ getLast (intercalate delim l) h₂ = getLast (getLast l (_ : l = [] → False)) (_ : getLast l (_ : l = [] → False) = [] → False) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
simp only [intercalate._eq_1, join, ne_eq, not_true] at h₂
α : Type u_1 delim : List α a : α l : List (List α) h₂ : intercalate delim [] ≠ [] not_nil : getLast? [] ≠ some [] ⊢ getLast (intercalate delim []) h₂ = getLast (getLast [] (_ : [] = [] → False)) (_ : getLast [] (_ : [] = [] → False) = [] → False)
no goals
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 delim : List α a : α l : List (List α) h₂ : intercalate delim [] ≠ [] not_nil : getLast? [] ≠ some [] ⊢ getLast (intercalate delim []) h₂ = getLast (getLast [] (_ : [] = [] → False)) (_ : getLast [] (_ : [] = [] → False) = [] → False) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
simp [intercalate]
α : Type u_1 delim : List α a✝ : α l : List (List α) a : List α h₂ : intercalate delim [a] ≠ [] not_nil : getLast? [a] ≠ some [] ⊢ getLast (intercalate delim [a]) h₂ = getLast (getLast [a] (_ : [a] = [] → False)) (_ : getLast [a] (_ : [a] = [] → False) = [] → False)
no goals
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 delim : List α a✝ : α l : List (List α) a : List α h₂ : intercalate delim [a] ≠ [] not_nil : getLast? [a] ≠ some [] ⊢ getLast (intercalate delim [a]) h₂ = getLast (getLast [a] (_ : [a] = [] → False)) (_ : getLast [a] (_ : [a] = [] → False) = [] → False) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
simp [intercalate]
α : Type u_1 delim : List α a✝ : α l : List (List α) a b : List α h₂ : intercalate delim [a, b] ≠ [] not_nil : getLast? [a, b] ≠ some [] ⊢ getLast (intercalate delim [a, b]) h₂ = getLast (getLast [a, b] (_ : [a, b] = [] → False)) (_ : getLast [a, b] (_ : [a, b] = [] → False) = [] → False)
α : Type u_1 delim : List α a✝ : α l : List (List α) a b : List α h₂ : intercalate delim [a, b] ≠ [] not_nil : getLast? [a, b] ≠ some [] ⊢ getLast (a ++ (delim ++ b)) (_ : a ++ (delim ++ b) ≠ []) = getLast b (_ : b ≠ [])
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 delim : List α a✝ : α l : List (List α) a b : List α h₂ : intercalate delim [a, b] ≠ [] not_nil : getLast? [a, b] ≠ some [] ⊢ getLast (intercalate delim [a, b]) h₂ = getLast (getLast [a, b] (_ : [a, b] = [] → False)) (_ : getLast [a, b] (_ : [a, b] = [] → False) = [] → False) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
simp only [← append_assoc]
α : Type u_1 delim : List α a✝ : α l : List (List α) a b : List α h₂ : intercalate delim [a, b] ≠ [] not_nil : getLast? [a, b] ≠ some [] ⊢ getLast (a ++ (delim ++ b)) (_ : a ++ (delim ++ b) ≠ []) = getLast b (_ : b ≠ [])
α : Type u_1 delim : List α a✝ : α l : List (List α) a b : List α h₂ : intercalate delim [a, b] ≠ [] not_nil : getLast? [a, b] ≠ some [] ⊢ getLast (a ++ delim ++ b) (_ : a ++ delim ++ b ≠ []) = getLast b (_ : b ≠ [])
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 delim : List α a✝ : α l : List (List α) a b : List α h₂ : intercalate delim [a, b] ≠ [] not_nil : getLast? [a, b] ≠ some [] ⊢ getLast (a ++ (delim ++ b)) (_ : a ++ (delim ++ b) ≠ []) = getLast b (_ : b ≠ []) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
rw [getLast_append']
α : Type u_1 delim : List α a✝ : α l : List (List α) a b : List α h₂ : intercalate delim [a, b] ≠ [] not_nil : getLast? [a, b] ≠ some [] ⊢ getLast (a ++ delim ++ b) (_ : a ++ delim ++ b ≠ []) = getLast b (_ : b ≠ [])
no goals
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 delim : List α a✝ : α l : List (List α) a b : List α h₂ : intercalate delim [a, b] ≠ [] not_nil : getLast? [a, b] ≠ some [] ⊢ getLast (a ++ delim ++ b) (_ : a ++ delim ++ b ≠ []) = getLast b (_ : b ≠ []) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
simp [intercalate]
α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ getLast (intercalate delim (head :: mid :: mid₂ :: tail)) h₂ = getLast (getLast (head :: mid :: mid₂ :: tail) (_ : head :: mid :: mid₂ :: tail = [] → False)) (_ : getLast (head :: mid :: mid₂ :: tail) (_ : head :: mid :: mid₂ :: tail = [] → False) = [] → False)
α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ getLast (head ++ (delim ++ (mid ++ (delim ++ join (intersperse delim (mid₂ :: tail)))))) (_ : head ++ (delim ++ (mid ++ (delim ++ join (intersperse delim (mid₂ :: tail))))) ≠ []) = getLast (getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = [])) (_ : getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = []) ≠ [])
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ getLast (intercalate delim (head :: mid :: mid₂ :: tail)) h₂ = getLast (getLast (head :: mid :: mid₂ :: tail) (_ : head :: mid :: mid₂ :: tail = [] → False)) (_ : getLast (head :: mid :: mid₂ :: tail) (_ : head :: mid :: mid₂ :: tail = [] → False) = [] → False) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
simp [← intercalate._eq_1]
α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ getLast (head ++ (delim ++ (mid ++ (delim ++ join (intersperse delim (mid₂ :: tail)))))) (_ : head ++ (delim ++ (mid ++ (delim ++ join (intersperse delim (mid₂ :: tail))))) ≠ []) = getLast (getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = [])) (_ : getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = []) ≠ [])
α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ getLast (head ++ (delim ++ (mid ++ (delim ++ intercalate delim (mid₂ :: tail))))) (_ : head ++ (delim ++ (mid ++ (delim ++ intercalate delim (mid₂ :: tail)))) ≠ []) = getLast (getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = [])) (_ : getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = []) ≠ [])
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ getLast (head ++ (delim ++ (mid ++ (delim ++ join (intersperse delim (mid₂ :: tail)))))) (_ : head ++ (delim ++ (mid ++ (delim ++ join (intersperse delim (mid₂ :: tail))))) ≠ []) = getLast (getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = [])) (_ : getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = []) ≠ []) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
simp only [← append_assoc]
α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ getLast (head ++ (delim ++ (mid ++ (delim ++ intercalate delim (mid₂ :: tail))))) (_ : head ++ (delim ++ (mid ++ (delim ++ intercalate delim (mid₂ :: tail)))) ≠ []) = getLast (getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = [])) (_ : getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = []) ≠ [])
α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ getLast (head ++ delim ++ mid ++ delim ++ intercalate delim (mid₂ :: tail)) (_ : head ++ delim ++ mid ++ delim ++ intercalate delim (mid₂ :: tail) ≠ []) = getLast (getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = [])) (_ : getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = []) ≠ [])
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ getLast (head ++ (delim ++ (mid ++ (delim ++ intercalate delim (mid₂ :: tail))))) (_ : head ++ (delim ++ (mid ++ (delim ++ intercalate delim (mid₂ :: tail)))) ≠ []) = getLast (getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = [])) (_ : getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = []) ≠ []) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
rw [getLast_append', getLast_intercalate (mid₂::tail)]
α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ getLast (head ++ delim ++ mid ++ delim ++ intercalate delim (mid₂ :: tail)) (_ : head ++ delim ++ mid ++ delim ++ intercalate delim (mid₂ :: tail) ≠ []) = getLast (getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = [])) (_ : getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = []) ≠ [])
case h₂ α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ intercalate delim (mid₂ :: tail) ≠ [] case not_nil α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ getLast? (mid₂ :: tail) ≠ some [] α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ α
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ getLast (head ++ delim ++ mid ++ delim ++ intercalate delim (mid₂ :: tail)) (_ : head ++ delim ++ mid ++ delim ++ intercalate delim (mid₂ :: tail) ≠ []) = getLast (getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = [])) (_ : getLast (mid₂ :: tail) (_ : ¬mid₂ :: tail = []) ≠ []) TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
. intro contr apply not_nil rw [List.getLast?_eq_getLast] simp only [ne_eq, not_false_iff, getLast_cons, Option.some.injEq] generalize_proofs hp apply List.intercalate_eq_nil contr (getLast (mid₂ :: tail) hp) apply List.getLast_mem simp only [ne_eq, not_false_iff]
case h₂ α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ intercalate delim (mid₂ :: tail) ≠ [] case not_nil α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ getLast? (mid₂ :: tail) ≠ some [] α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ α
case not_nil α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ getLast? (mid₂ :: tail) ≠ some [] α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ α
Please generate a tactic in lean4 to solve the state. STATE: case h₂ α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ intercalate delim (mid₂ :: tail) ≠ [] case not_nil α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ getLast? (mid₂ :: tail) ≠ some [] α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ α TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
. intro contr apply not_nil simp only [getLast?_cons_cons, contr]
case not_nil α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ getLast? (mid₂ :: tail) ≠ some [] α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ α
α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ α
Please generate a tactic in lean4 to solve the state. STATE: case not_nil α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ getLast? (mid₂ :: tail) ≠ some [] α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ α TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.getLast_intercalate
[2077, 1]
[2106, 14]
. exact a
α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ α
no goals
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 delim : List α a : α l : List (List α) head mid mid₂ : List α tail : List (List α) h₂ : intercalate delim (head :: mid :: mid₂ :: tail) ≠ [] not_nil : getLast? (head :: mid :: mid₂ :: tail) ≠ some [] ⊢ α TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_of_mem_take
[2110, 1]
[2112, 28]
rw [← take_append_drop n l]
α✝ : Type u_1 a : α✝ l : List α✝ n : ℕ h : a ∈ take n l ⊢ a ∈ l
α✝ : Type u_1 a : α✝ l : List α✝ n : ℕ h : a ∈ take n l ⊢ a ∈ take n l ++ drop n l
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a : α✝ l : List α✝ n : ℕ h : a ∈ take n l ⊢ a ∈ l TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.mem_of_mem_take
[2110, 1]
[2112, 28]
apply mem_append_left _ h
α✝ : Type u_1 a : α✝ l : List α✝ n : ℕ h : a ∈ take n l ⊢ a ∈ take n l ++ drop n l
no goals
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 a : α✝ l : List α✝ n : ℕ h : a ∈ take n l ⊢ a ∈ take n l ++ drop n l TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.countp_nil
[2114, 1]
[2117, 6]
unfold countp countp.go
α✝ : Type u_1 p : α✝ → Bool ⊢ countp p [] = 0
α✝ : Type u_1 p : α✝ → Bool ⊢ 0 = 0
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 p : α✝ → Bool ⊢ countp p [] = 0 TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.countp_nil
[2114, 1]
[2117, 6]
rfl
α✝ : Type u_1 p : α✝ → Bool ⊢ 0 = 0
no goals
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 p : α✝ → Bool ⊢ 0 = 0 TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.countp.go_acc
[2119, 1]
[2126, 97]
induction l generalizing acc with | nil => unfold go; simp | cons head tail ih => unfold go cases p head with | true => simp only [@ih (acc + 1), add_assoc, zero_le, ge_iff_le, nonpos_iff_eq_zero, cond_true, zero_add, @ih 1] | false => simp only [@ih acc, zero_le, ge_iff_le, nonpos_iff_eq_zero, cond_false, zero_add]
α✝ : Type u_1 p : α✝ → Bool l : List α✝ acc : ℕ ⊢ go p l acc = acc + go p l 0
no goals
Please generate a tactic in lean4 to solve the state. STATE: α✝ : Type u_1 p : α✝ → Bool l : List α✝ acc : ℕ ⊢ go p l acc = acc + go p l 0 TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.countp.go_acc
[2119, 1]
[2126, 97]
unfold go
case nil α✝ : Type u_1 p : α✝ → Bool acc : ℕ ⊢ go p [] acc = acc + go p [] 0
case nil α✝ : Type u_1 p : α✝ → Bool acc : ℕ ⊢ acc = acc + 0
Please generate a tactic in lean4 to solve the state. STATE: case nil α✝ : Type u_1 p : α✝ → Bool acc : ℕ ⊢ go p [] acc = acc + go p [] 0 TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.countp.go_acc
[2119, 1]
[2126, 97]
simp
case nil α✝ : Type u_1 p : α✝ → Bool acc : ℕ ⊢ acc = acc + 0
no goals
Please generate a tactic in lean4 to solve the state. STATE: case nil α✝ : Type u_1 p : α✝ → Bool acc : ℕ ⊢ acc = acc + 0 TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.countp.go_acc
[2119, 1]
[2126, 97]
unfold go
case cons α✝ : Type u_1 p : α✝ → Bool head : α✝ tail : List α✝ ih : ∀ {acc : ℕ}, go p tail acc = acc + go p tail 0 acc : ℕ ⊢ go p (head :: tail) acc = acc + go p (head :: tail) 0
case cons α✝ : Type u_1 p : α✝ → Bool head : α✝ tail : List α✝ ih : ∀ {acc : ℕ}, go p tail acc = acc + go p tail 0 acc : ℕ ⊢ (bif p head then go p tail (acc + 1) else go p tail acc) = acc + bif p head then go p tail (0 + 1) else go p tail 0
Please generate a tactic in lean4 to solve the state. STATE: case cons α✝ : Type u_1 p : α✝ → Bool head : α✝ tail : List α✝ ih : ∀ {acc : ℕ}, go p tail acc = acc + go p tail 0 acc : ℕ ⊢ go p (head :: tail) acc = acc + go p (head :: tail) 0 TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.countp.go_acc
[2119, 1]
[2126, 97]
cases p head with | true => simp only [@ih (acc + 1), add_assoc, zero_le, ge_iff_le, nonpos_iff_eq_zero, cond_true, zero_add, @ih 1] | false => simp only [@ih acc, zero_le, ge_iff_le, nonpos_iff_eq_zero, cond_false, zero_add]
case cons α✝ : Type u_1 p : α✝ → Bool head : α✝ tail : List α✝ ih : ∀ {acc : ℕ}, go p tail acc = acc + go p tail 0 acc : ℕ ⊢ (bif p head then go p tail (acc + 1) else go p tail acc) = acc + bif p head then go p tail (0 + 1) else go p tail 0
no goals
Please generate a tactic in lean4 to solve the state. STATE: case cons α✝ : Type u_1 p : α✝ → Bool head : α✝ tail : List α✝ ih : ∀ {acc : ℕ}, go p tail acc = acc + go p tail 0 acc : ℕ ⊢ (bif p head then go p tail (acc + 1) else go p tail acc) = acc + bif p head then go p tail (0 + 1) else go p tail 0 TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.countp.go_acc
[2119, 1]
[2126, 97]
simp only [@ih (acc + 1), add_assoc, zero_le, ge_iff_le, nonpos_iff_eq_zero, cond_true, zero_add, @ih 1]
case cons.true α✝ : Type u_1 p : α✝ → Bool head : α✝ tail : List α✝ ih : ∀ {acc : ℕ}, go p tail acc = acc + go p tail 0 acc : ℕ ⊢ (bif true then go p tail (acc + 1) else go p tail acc) = acc + bif true then go p tail (0 + 1) else go p tail 0
no goals
Please generate a tactic in lean4 to solve the state. STATE: case cons.true α✝ : Type u_1 p : α✝ → Bool head : α✝ tail : List α✝ ih : ∀ {acc : ℕ}, go p tail acc = acc + go p tail 0 acc : ℕ ⊢ (bif true then go p tail (acc + 1) else go p tail acc) = acc + bif true then go p tail (0 + 1) else go p tail 0 TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.countp.go_acc
[2119, 1]
[2126, 97]
simp only [@ih acc, zero_le, ge_iff_le, nonpos_iff_eq_zero, cond_false, zero_add]
case cons.false α✝ : Type u_1 p : α✝ → Bool head : α✝ tail : List α✝ ih : ∀ {acc : ℕ}, go p tail acc = acc + go p tail 0 acc : ℕ ⊢ (bif false then go p tail (acc + 1) else go p tail acc) = acc + bif false then go p tail (0 + 1) else go p tail 0
no goals
Please generate a tactic in lean4 to solve the state. STATE: case cons.false α✝ : Type u_1 p : α✝ → Bool head : α✝ tail : List α✝ ih : ∀ {acc : ℕ}, go p tail acc = acc + go p tail 0 acc : ℕ ⊢ (bif false then go p tail (acc + 1) else go p tail acc) = acc + bif false then go p tail (0 + 1) else go p tail 0 TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.countp_cons
[2129, 1]
[2133, 112]
rw [countp, countp.go]
α : Type u_1 p : α → Bool head : α tail : List α ⊢ countp p (head :: tail) = (if p head = true then 1 else 0) + countp p tail
α : Type u_1 p : α → Bool head : α tail : List α ⊢ (bif p head then countp.go p tail (0 + 1) else countp.go p tail 0) = (if p head = true then 1 else 0) + countp p tail
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 p : α → Bool head : α tail : List α ⊢ countp p (head :: tail) = (if p head = true then 1 else 0) + countp p tail TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.countp_cons
[2129, 1]
[2133, 112]
cases p head with | true => simp only [zero_le, ge_iff_le, nonpos_iff_eq_zero, zero_add, cond_true, ite_true]; rw [List.countp.go_acc, ← countp] | false => simp only [zero_le, ge_iff_le, nonpos_iff_eq_zero, zero_add, cond_false, ite_false]; rw [← countp]
α : Type u_1 p : α → Bool head : α tail : List α ⊢ (bif p head then countp.go p tail (0 + 1) else countp.go p tail 0) = (if p head = true then 1 else 0) + countp p tail
no goals
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 p : α → Bool head : α tail : List α ⊢ (bif p head then countp.go p tail (0 + 1) else countp.go p tail 0) = (if p head = true then 1 else 0) + countp p tail TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.countp_cons
[2129, 1]
[2133, 112]
simp only [zero_le, ge_iff_le, nonpos_iff_eq_zero, zero_add, cond_true, ite_true]
case true α : Type u_1 p : α → Bool head : α tail : List α ⊢ (bif true then countp.go p tail (0 + 1) else countp.go p tail 0) = (if true = true then 1 else 0) + countp p tail
case true α : Type u_1 p : α → Bool head : α tail : List α ⊢ countp.go p tail 1 = 1 + countp p tail
Please generate a tactic in lean4 to solve the state. STATE: case true α : Type u_1 p : α → Bool head : α tail : List α ⊢ (bif true then countp.go p tail (0 + 1) else countp.go p tail 0) = (if true = true then 1 else 0) + countp p tail TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.countp_cons
[2129, 1]
[2133, 112]
rw [List.countp.go_acc, ← countp]
case true α : Type u_1 p : α → Bool head : α tail : List α ⊢ countp.go p tail 1 = 1 + countp p tail
no goals
Please generate a tactic in lean4 to solve the state. STATE: case true α : Type u_1 p : α → Bool head : α tail : List α ⊢ countp.go p tail 1 = 1 + countp p tail TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.countp_cons
[2129, 1]
[2133, 112]
simp only [zero_le, ge_iff_le, nonpos_iff_eq_zero, zero_add, cond_false, ite_false]
case false α : Type u_1 p : α → Bool head : α tail : List α ⊢ (bif false then countp.go p tail (0 + 1) else countp.go p tail 0) = (if false = true then 1 else 0) + countp p tail
case false α : Type u_1 p : α → Bool head : α tail : List α ⊢ countp.go p tail 0 = countp p tail
Please generate a tactic in lean4 to solve the state. STATE: case false α : Type u_1 p : α → Bool head : α tail : List α ⊢ (bif false then countp.go p tail (0 + 1) else countp.go p tail 0) = (if false = true then 1 else 0) + countp p tail TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.countp_cons
[2129, 1]
[2133, 112]
rw [← countp]
case false α : Type u_1 p : α → Bool head : α tail : List α ⊢ countp.go p tail 0 = countp p tail
no goals
Please generate a tactic in lean4 to solve the state. STATE: case false α : Type u_1 p : α → Bool head : α tail : List α ⊢ countp.go p tail 0 = countp p tail TACTIC:
https://github.com/jeremysalwen/advent_of_lean_2022.git
96035d07c4f9f133fe79fe02cdf5792b597881c0
One.lean
List.count_nil
[2135, 1]
[2138, 19]
unfold count
α : Type u_1 inst✝ : BEq α a : α ⊢ count a [] = 0
α : Type u_1 inst✝ : BEq α a : α ⊢ countp (fun x => x == a) [] = 0
Please generate a tactic in lean4 to solve the state. STATE: α : Type u_1 inst✝ : BEq α a : α ⊢ count a [] = 0 TACTIC: