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.isInfix_take_of_isInfix_append | [1653, 1] | [1676, 70] | have ⟨s,t,ih⟩ := h | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
⊢ take (length l₁ - length l₃) l₁ <:+: l₂ | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : s ++ l₁ ++ t = l₂ ++ l₃
⊢ take (length l₁ - length l₃) l₁ <:+: l₂ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
⊢ take (length l₁ - length l₃) l₁ <:+: l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.isInfix_take_of_isInfix_append | [1653, 1] | [1676, 70] | have hl: s.length + l₁.length + t.length = l₂.length + l₃.length := by
apply_fun @List.length α at ih
simp only [List.length_append] at ih
exact ih | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : s ++ l₁ ++ t = l₂ ++ l₃
⊢ take (length l₁ - length l₃) l₁ <:+: l₂ | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : s ++ l₁ ++ t = l₂ ++ l₃
hl : length s + length l₁ + length t = length l₂ + length l₃
⊢ take (length l₁ - length l₃) l₁ <:+: l₂ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : s ++ l₁ ++ t = l₂ ++ l₃
⊢ take (length l₁ - length l₃) l₁ <:+: l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.isInfix_take_of_isInfix_append | [1653, 1] | [1676, 70] | have l₁split := List.take_append_drop (length l₁ - length l₃) l₁ | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : s ++ l₁ ++ t = l₂ ++ l₃
hl : length s + length l₁ + length t = length l₂ + length l₃
⊢ take (length l₁ - length l₃) l₁ <:+: l₂ | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : s ++ l₁ ++ t = l₂ ++ l₃
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
⊢ take (length l₁ - length l₃) l₁ <:+: l₂ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : s ++ l₁ ++ t = l₂ ++ l₃
hl : length s + length l₁ + length t = length l₂ + length l₃
⊢ take (length l₁ - length l₃) l₁ <:+: l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.isInfix_take_of_isInfix_append | [1653, 1] | [1676, 70] | rw [←l₁split] at ih | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : s ++ l₁ ++ t = l₂ ++ l₃
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
⊢ take (length l₁ - length l₃) l₁ <:+: l₂ | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : s ++ (take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁) ++ t = l₂ ++ l₃
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
⊢ take (length l₁ - length l₃) l₁ <:+: l₂ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : s ++ l₁ ++ t = l₂ ++ l₃
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
⊢ take (length l₁ - length l₃) l₁ <:+: l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.isInfix_take_of_isInfix_append | [1653, 1] | [1676, 70] | apply_fun List.take (length l₂) at ih | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : s ++ (take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁) ++ t = l₂ ++ l₃
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
⊢ take (length l₁ - length l₃) l₁ <:+: l₂ | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length l₂) (s ++ (take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁) ++ t) =
take (length l₂) (l₂ ++ l₃)
⊢ take (length l₁ - length l₃) l₁ <:+: l₂ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : s ++ (take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁) ++ t = l₂ ++ l₃
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
⊢ take (length l₁ - length l₃) l₁ <:+: l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.isInfix_take_of_isInfix_append | [1653, 1] | [1676, 70] | simp only [List.take_append_eq_append_take, List.take_take, List.length_take, length_drop, length_append,
take_length, Nat.sub_self, take_zero, append_nil, Nat.min_self_sub_left] at ih | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length l₂) (s ++ (take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁) ++ t) =
take (length l₂) (l₂ ++ l₃)
⊢ take (length l₁ - length l₃) l₁ <:+: l₂ | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length l₂) s ++
(take (min (length l₂ - length s) (length l₁ - length l₃)) l₁ ++
take (length l₂ - length s - (length l₁ - length l₃)) (drop (length l₁ - length l₃) l₁)) ++
take (length l₂ - (length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃))))) t =
l₂
⊢ take (length l₁ - length l₃) l₁ <:+: l₂ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length l₂) (s ++ (take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁) ++ t) =
take (length l₂) (l₂ ++ l₃)
⊢ take (length l₁ - length l₃) l₁ <:+: l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.isInfix_take_of_isInfix_append | [1653, 1] | [1676, 70] | have l2len : l₂.length = s.length + l₁.length + t.length - l₃.length := by
apply Eq.symm
rw [Nat.sub_eq_of_eq_add]
exact hl | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length l₂) s ++
(take (min (length l₂ - length s) (length l₁ - length l₃)) l₁ ++
take (length l₂ - length s - (length l₁ - length l₃)) (drop (length l₁ - length l₃) l₁)) ++
take (length l₂ - (length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃))))) t =
l₂
⊢ take (length l₁ - length l₃) l₁ <:+: l₂ | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length l₂) s ++
(take (min (length l₂ - length s) (length l₁ - length l₃)) l₁ ++
take (length l₂ - length s - (length l₁ - length l₃)) (drop (length l₁ - length l₃) l₁)) ++
take (length l₂ - (length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃))))) t =
l₂
l2len : length l₂ = length s + length l₁ + length t - length l₃
⊢ take (length l₁ - length l₃) l₁ <:+: l₂ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length l₂) s ++
(take (min (length l₂ - length s) (length l₁ - length l₃)) l₁ ++
take (length l₂ - length s - (length l₁ - length l₃)) (drop (length l₁ - length l₃) l₁)) ++
take (length l₂ - (length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃))))) t =
l₂
⊢ take (length l₁ - length l₃) l₁ <:+: l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.isInfix_take_of_isInfix_append | [1653, 1] | [1676, 70] | rw [l2len, min_eq_right] at ih | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length l₂) s ++
(take (min (length l₂ - length s) (length l₁ - length l₃)) l₁ ++
take (length l₂ - length s - (length l₁ - length l₃)) (drop (length l₁ - length l₃) l₁)) ++
take (length l₂ - (length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃))))) t =
l₂
l2len : length l₂ = length s + length l₁ + length t - length l₃
⊢ take (length l₁ - length l₃) l₁ <:+: l₂ | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length s + length l₁ + length t - length l₃) s ++
(take (length l₁ - length l₃) l₁ ++
take (length s + length l₁ + length t - length l₃ - length s - (length l₁ - length l₃))
(drop (length l₁ - length l₃) l₁)) ++
take
(length s + length l₁ + length t - length l₃ -
(length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃)))))
t =
l₂
l2len : length l₂ = length s + length l₁ + length t - length l₃
⊢ take (length l₁ - length l₃) l₁ <:+: l₂
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length s + length l₁ + length t - length l₃) s ++
(take (min (length s + length l₁ + length t - length l₃ - length s) (length l₁ - length l₃)) l₁ ++
take (length s + length l₁ + length t - length l₃ - length s - (length l₁ - length l₃))
(drop (length l₁ - length l₃) l₁)) ++
take
(length s + length l₁ + length t - length l₃ -
(length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃)))))
t =
l₂
l2len : length l₂ = length s + length l₁ + length t - length l₃
⊢ length l₁ - length l₃ ≤ length s + length l₁ + length t - length l₃ - length s | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length l₂) s ++
(take (min (length l₂ - length s) (length l₁ - length l₃)) l₁ ++
take (length l₂ - length s - (length l₁ - length l₃)) (drop (length l₁ - length l₃) l₁)) ++
take (length l₂ - (length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃))))) t =
l₂
l2len : length l₂ = length s + length l₁ + length t - length l₃
⊢ take (length l₁ - length l₃) l₁ <:+: l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.isInfix_take_of_isInfix_append | [1653, 1] | [1676, 70] | . rw [← ih]
apply List.isInfix_append_right_of_isInfix
apply List.isInfix_append_left_of_isInfix
apply List.isInfix_append_right_of_isInfix
apply List.isInfix_self | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length s + length l₁ + length t - length l₃) s ++
(take (length l₁ - length l₃) l₁ ++
take (length s + length l₁ + length t - length l₃ - length s - (length l₁ - length l₃))
(drop (length l₁ - length l₃) l₁)) ++
take
(length s + length l₁ + length t - length l₃ -
(length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃)))))
t =
l₂
l2len : length l₂ = length s + length l₁ + length t - length l₃
⊢ take (length l₁ - length l₃) l₁ <:+: l₂
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length s + length l₁ + length t - length l₃) s ++
(take (min (length s + length l₁ + length t - length l₃ - length s) (length l₁ - length l₃)) l₁ ++
take (length s + length l₁ + length t - length l₃ - length s - (length l₁ - length l₃))
(drop (length l₁ - length l₃) l₁)) ++
take
(length s + length l₁ + length t - length l₃ -
(length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃)))))
t =
l₂
l2len : length l₂ = length s + length l₁ + length t - length l₃
⊢ length l₁ - length l₃ ≤ length s + length l₁ + length t - length l₃ - length s | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length s + length l₁ + length t - length l₃) s ++
(take (min (length s + length l₁ + length t - length l₃ - length s) (length l₁ - length l₃)) l₁ ++
take (length s + length l₁ + length t - length l₃ - length s - (length l₁ - length l₃))
(drop (length l₁ - length l₃) l₁)) ++
take
(length s + length l₁ + length t - length l₃ -
(length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃)))))
t =
l₂
l2len : length l₂ = length s + length l₁ + length t - length l₃
⊢ length l₁ - length l₃ ≤ length s + length l₁ + length t - length l₃ - length s | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length s + length l₁ + length t - length l₃) s ++
(take (length l₁ - length l₃) l₁ ++
take (length s + length l₁ + length t - length l₃ - length s - (length l₁ - length l₃))
(drop (length l₁ - length l₃) l₁)) ++
take
(length s + length l₁ + length t - length l₃ -
(length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃)))))
t =
l₂
l2len : length l₂ = length s + length l₁ + length t - length l₃
⊢ take (length l₁ - length l₃) l₁ <:+: l₂
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length s + length l₁ + length t - length l₃) s ++
(take (min (length s + length l₁ + length t - length l₃ - length s) (length l₁ - length l₃)) l₁ ++
take (length s + length l₁ + length t - length l₃ - length s - (length l₁ - length l₃))
(drop (length l₁ - length l₃) l₁)) ++
take
(length s + length l₁ + length t - length l₃ -
(length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃)))))
t =
l₂
l2len : length l₂ = length s + length l₁ + length t - length l₃
⊢ length l₁ - length l₃ ≤ length s + length l₁ + length t - length l₃ - length s
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.isInfix_take_of_isInfix_append | [1653, 1] | [1676, 70] | . rw [Nat.sub_sub, add_comm l₃.length, ← Nat.sub_sub, add_assoc, add_comm, Nat.add_sub_cancel, add_comm]
simp only [Nat.sub_le_sub_right, le_add_iff_nonneg_left, zero_le] | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length s + length l₁ + length t - length l₃) s ++
(take (min (length s + length l₁ + length t - length l₃ - length s) (length l₁ - length l₃)) l₁ ++
take (length s + length l₁ + length t - length l₃ - length s - (length l₁ - length l₃))
(drop (length l₁ - length l₃) l₁)) ++
take
(length s + length l₁ + length t - length l₃ -
(length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃)))))
t =
l₂
l2len : length l₂ = length s + length l₁ + length t - length l₃
⊢ length l₁ - length l₃ ≤ length s + length l₁ + length t - length l₃ - length s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length s + length l₁ + length t - length l₃) s ++
(take (min (length s + length l₁ + length t - length l₃ - length s) (length l₁ - length l₃)) l₁ ++
take (length s + length l₁ + length t - length l₃ - length s - (length l₁ - length l₃))
(drop (length l₁ - length l₃) l₁)) ++
take
(length s + length l₁ + length t - length l₃ -
(length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃)))))
t =
l₂
l2len : length l₂ = length s + length l₁ + length t - length l₃
⊢ length l₁ - length l₃ ≤ length s + length l₁ + length t - length l₃ - length s
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.isInfix_take_of_isInfix_append | [1653, 1] | [1676, 70] | apply_fun @List.length α at ih | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : s ++ l₁ ++ t = l₂ ++ l₃
⊢ length s + length l₁ + length t = length l₂ + length l₃ | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : length (s ++ l₁ ++ t) = length (l₂ ++ l₃)
⊢ length s + length l₁ + length t = length l₂ + length l₃ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : s ++ l₁ ++ t = l₂ ++ l₃
⊢ length s + length l₁ + length t = length l₂ + length l₃
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.isInfix_take_of_isInfix_append | [1653, 1] | [1676, 70] | simp only [List.length_append] at ih | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : length (s ++ l₁ ++ t) = length (l₂ ++ l₃)
⊢ length s + length l₁ + length t = length l₂ + length l₃ | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : length s + length l₁ + length t = length l₂ + length l₃
⊢ length s + length l₁ + length t = length l₂ + length l₃ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : length (s ++ l₁ ++ t) = length (l₂ ++ l₃)
⊢ length s + length l₁ + length t = length l₂ + length l₃
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.isInfix_take_of_isInfix_append | [1653, 1] | [1676, 70] | exact ih | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : length s + length l₁ + length t = length l₂ + length l₃
⊢ length s + length l₁ + length t = length l₂ + length l₃ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
ih : length s + length l₁ + length t = length l₂ + length l₃
⊢ length s + length l₁ + length t = length l₂ + length l₃
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.isInfix_take_of_isInfix_append | [1653, 1] | [1676, 70] | apply Eq.symm | α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length l₂) s ++
(take (min (length l₂ - length s) (length l₁ - length l₃)) l₁ ++
take (length l₂ - length s - (length l₁ - length l₃)) (drop (length l₁ - length l₃) l₁)) ++
take (length l₂ - (length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃))))) t =
l₂
⊢ length l₂ = length s + length l₁ + length t - length l₃ | case h
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length l₂) s ++
(take (min (length l₂ - length s) (length l₁ - length l₃)) l₁ ++
take (length l₂ - length s - (length l₁ - length l₃)) (drop (length l₁ - length l₃) l₁)) ++
take (length l₂ - (length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃))))) t =
l₂
⊢ length s + length l₁ + length t - length l₃ = length l₂ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length l₂) s ++
(take (min (length l₂ - length s) (length l₁ - length l₃)) l₁ ++
take (length l₂ - length s - (length l₁ - length l₃)) (drop (length l₁ - length l₃) l₁)) ++
take (length l₂ - (length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃))))) t =
l₂
⊢ length l₂ = length s + length l₁ + length t - length l₃
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.isInfix_take_of_isInfix_append | [1653, 1] | [1676, 70] | rw [Nat.sub_eq_of_eq_add] | case h
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length l₂) s ++
(take (min (length l₂ - length s) (length l₁ - length l₃)) l₁ ++
take (length l₂ - length s - (length l₁ - length l₃)) (drop (length l₁ - length l₃) l₁)) ++
take (length l₂ - (length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃))))) t =
l₂
⊢ length s + length l₁ + length t - length l₃ = length l₂ | case h
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length l₂) s ++
(take (min (length l₂ - length s) (length l₁ - length l₃)) l₁ ++
take (length l₂ - length s - (length l₁ - length l₃)) (drop (length l₁ - length l₃) l₁)) ++
take (length l₂ - (length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃))))) t =
l₂
⊢ length s + length l₁ + length t = length l₂ + length l₃ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length l₂) s ++
(take (min (length l₂ - length s) (length l₁ - length l₃)) l₁ ++
take (length l₂ - length s - (length l₁ - length l₃)) (drop (length l₁ - length l₃) l₁)) ++
take (length l₂ - (length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃))))) t =
l₂
⊢ length s + length l₁ + length t - length l₃ = length l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.isInfix_take_of_isInfix_append | [1653, 1] | [1676, 70] | exact hl | case h
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length l₂) s ++
(take (min (length l₂ - length s) (length l₁ - length l₃)) l₁ ++
take (length l₂ - length s - (length l₁ - length l₃)) (drop (length l₁ - length l₃) l₁)) ++
take (length l₂ - (length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃))))) t =
l₂
⊢ length s + length l₁ + length t = length l₂ + length l₃ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
l₁ l₂ l₃ : List α
h : l₁ <:+: l₂ ++ l₃
s t : List α
hl : length s + length l₁ + length t = length l₂ + length l₃
l₁split : take (length l₁ - length l₃) l₁ ++ drop (length l₁ - length l₃) l₁ = l₁
ih :
take (length l₂) s ++
(take (min (length l₂ - length s) (length l₁ - length l₃)) l₁ ++
take (length l₂ - length s - (length l₁ - length l₃)) (drop (length l₁ - length l₃) l₁)) ++
take (length l₂ - (length s + (length l₁ - length l₃ + (length l₁ - (length l₁ - length l₃))))) t =
l₂
⊢ length s + length l₁ + length t = length l₂ + length l₃
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.singleton_isInfix_iff_mem | [1680, 1] | [1687, 43] | apply Iff.intro | α✝ : Type u_1
e : α✝
l : List α✝
⊢ [e] <:+: l ↔ e ∈ l | case mp
α✝ : Type u_1
e : α✝
l : List α✝
⊢ [e] <:+: l → e ∈ l
case mpr
α✝ : Type u_1
e : α✝
l : List α✝
⊢ e ∈ l → [e] <:+: l | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
e : α✝
l : List α✝
⊢ [e] <:+: l ↔ e ∈ l
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.singleton_isInfix_iff_mem | [1680, 1] | [1687, 43] | . intro ⟨s,t,h⟩
simp only [append_assoc, singleton_append, mem_append, find?, mem_cons, true_or, or_true, ← h] | case mp
α✝ : Type u_1
e : α✝
l : List α✝
⊢ [e] <:+: l → e ∈ l
case mpr
α✝ : Type u_1
e : α✝
l : List α✝
⊢ e ∈ l → [e] <:+: l | case mpr
α✝ : Type u_1
e : α✝
l : List α✝
⊢ e ∈ l → [e] <:+: l | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α✝ : Type u_1
e : α✝
l : List α✝
⊢ [e] <:+: l → e ∈ l
case mpr
α✝ : Type u_1
e : α✝
l : List α✝
⊢ e ∈ l → [e] <:+: l
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.singleton_isInfix_iff_mem | [1680, 1] | [1687, 43] | . intro mem
have ⟨s,t,h⟩ := List.mem_split mem
exists s,t
rw [h, append_assoc, singleton_append] | case mpr
α✝ : Type u_1
e : α✝
l : List α✝
⊢ e ∈ l → [e] <:+: l | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α✝ : Type u_1
e : α✝
l : List α✝
⊢ e ∈ l → [e] <:+: l
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | cases heq: List.isInfixOf delim (l₁ ++ l₂) with
| true =>
rw [List.isInfixOf_ext] at heq
have ⟨s, lft, rgt⟩ := (List.isInfix_first_match _ _ heq h₂)
cases List.append_isPrefix_split lft (length l₁) with
| inl hinf =>
rw [List.take_append_of_le_length] at hinf <;> simp only [tsub_le_iff_right, ge_iff_le, le_add_iff_nonneg_right, zero_le, nonpos_iff_eq_zero]
have ⟨t, hinf⟩ := isPrefix_trans hinf take_isPrefix
rw [← hinf]
have hrw₁: s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂) := by simp only [append_assoc]
have hrw₂: s ++ delim ++ t = s ++ delim ++ t := by simp only [append_assoc]
rw [hrw₁, hrw₂, splitOnListAux_progress rgt, splitOnListAux_progress rgt]
have _ : length t < length l₁ := by
apply_fun @List.length α at hinf
rw [← hinf, length_append, length_append]
apply Nat.lt_add_of_pos_left
apply Nat.add_pos_right
apply List.length_pos_of_ne_nil h₂
rw [List.splitOnListAux_append t]
. apply Array.ext'
simp only [Array.append_data, Array.data_toArray, Array.modifyLast_data, singleton_append]
cases h₃: (splitOnListAux delim t #[] #[] h₂).data with
| nil =>
exfalso
apply @splitOnListAux_ne_nil α delim #[] #[] h₂ _ t
apply Array.ext'
simp only [h₃, Array.data_toArray]
| cons head tail=> conv => right; rw [List.modifyLast_cons (List.cons_ne_nil head tail)]
. rw [← hinf] at h
intro contr
apply h
unfold lastN
unfold lastN at contr
rw [List.drop_append_eq_append_drop,List.drop_append_eq_append_drop]
simp only [append_assoc, length_append, tsub_le_iff_right, ge_iff_le, add_le_add_iff_left]
apply List.isInfix_append_left_of_isInfix
apply List.isInfix_append_left_of_isInfix
convert contr using 3
rw [ Nat.add_comm (length delim), ← Nat.add_assoc, Nat.add_sub_assoc, Nat.sub_sub_self, ←Nat.sub_sub,
Nat.add_comm (length s), Nat.add_assoc, Nat.add_comm (length s), ← Nat.add_assoc, Nat.add_sub_assoc, Nat.sub_self,
Nat.add_zero]
. rw [Nat.sub_sub_eq_add_sub_of_le]
apply Nat.succ_le.2
simp only [zero_le, ge_iff_le, nonpos_iff_eq_zero, ne_eq, h₂, not_false_iff, length_pos_of_ne_nil]
. simp only [le_refl]
. apply Nat.succ_le.2
simp only [zero_le, ge_iff_le, nonpos_iff_eq_zero, ne_eq, h₂, not_false_iff, length_pos_of_ne_nil]
. simp only [tsub_le_iff_right, ge_iff_le, le_add_iff_nonneg_right]
. apply le_refl
| inr hinf =>
have hzero: length l₁ + 1 - length delim - length l₁ = 0 := by
simp only [tsub_le_iff_right, ge_iff_le, add_le_add_iff_left, zero_le, nonpos_iff_eq_zero,
tsub_eq_zero_iff_le]
apply Nat.succ_le_of_lt
simp only [zero_le, ge_iff_le, nonpos_iff_eq_zero, ne_eq, h₂, not_false_iff, length_pos_of_ne_nil]
rw [List.drop_append_eq_append_drop, hzero, drop] at hinf
have ⟨t, hinf⟩ := hinf
unfold lastN at h
exfalso
apply h
exists drop (length l₁ + 1 - length delim) s, t
convert hinf using 3
rw [Nat.sub_sub_eq_add_sub_of_le]
apply Nat.succ_le_of_lt
apply Nat.zero_lt_of_ne_zero
simp only [zero_le, ge_iff_le, nonpos_iff_eq_zero, ne_eq, length_eq_zero, h₂, not_false_iff]
| false =>
rw [← Bool.not_eq_true, isInfixOf_ext] at heq
have not_in_l₁: ¬ delim <:+: l₁ := by
intro contr;
apply heq
apply List.isInfix_append_right_of_isInfix contr
rw [splitOnListAux_nonmatching _ heq, splitOnListAux_nonmatching _ not_in_l₁]
apply Array.ext'
simp only [Array.data_toArray, Array.modifyLast_data, modifyLast_singleton, cons.injEq, and_true]
apply Array.ext'
simp only [Array.data_toArray, Array.append_data] | α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | rw [List.isInfixOf_ext] at heq | case true
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : isInfixOf delim (l₁ ++ l₂) = true
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | case true
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | Please generate a tactic in lean4 to solve the state.
STATE:
case true
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : isInfixOf delim (l₁ ++ l₂) = true
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | have ⟨s, lft, rgt⟩ := (List.isInfix_first_match _ _ heq h₂) | case true
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | case true
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | Please generate a tactic in lean4 to solve the state.
STATE:
case true
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | cases List.append_isPrefix_split lft (length l₁) with
| inl hinf =>
rw [List.take_append_of_le_length] at hinf <;> simp only [tsub_le_iff_right, ge_iff_le, le_add_iff_nonneg_right, zero_le, nonpos_iff_eq_zero]
have ⟨t, hinf⟩ := isPrefix_trans hinf take_isPrefix
rw [← hinf]
have hrw₁: s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂) := by simp only [append_assoc]
have hrw₂: s ++ delim ++ t = s ++ delim ++ t := by simp only [append_assoc]
rw [hrw₁, hrw₂, splitOnListAux_progress rgt, splitOnListAux_progress rgt]
have _ : length t < length l₁ := by
apply_fun @List.length α at hinf
rw [← hinf, length_append, length_append]
apply Nat.lt_add_of_pos_left
apply Nat.add_pos_right
apply List.length_pos_of_ne_nil h₂
rw [List.splitOnListAux_append t]
. apply Array.ext'
simp only [Array.append_data, Array.data_toArray, Array.modifyLast_data, singleton_append]
cases h₃: (splitOnListAux delim t #[] #[] h₂).data with
| nil =>
exfalso
apply @splitOnListAux_ne_nil α delim #[] #[] h₂ _ t
apply Array.ext'
simp only [h₃, Array.data_toArray]
| cons head tail=> conv => right; rw [List.modifyLast_cons (List.cons_ne_nil head tail)]
. rw [← hinf] at h
intro contr
apply h
unfold lastN
unfold lastN at contr
rw [List.drop_append_eq_append_drop,List.drop_append_eq_append_drop]
simp only [append_assoc, length_append, tsub_le_iff_right, ge_iff_le, add_le_add_iff_left]
apply List.isInfix_append_left_of_isInfix
apply List.isInfix_append_left_of_isInfix
convert contr using 3
rw [ Nat.add_comm (length delim), ← Nat.add_assoc, Nat.add_sub_assoc, Nat.sub_sub_self, ←Nat.sub_sub,
Nat.add_comm (length s), Nat.add_assoc, Nat.add_comm (length s), ← Nat.add_assoc, Nat.add_sub_assoc, Nat.sub_self,
Nat.add_zero]
. rw [Nat.sub_sub_eq_add_sub_of_le]
apply Nat.succ_le.2
simp only [zero_le, ge_iff_le, nonpos_iff_eq_zero, ne_eq, h₂, not_false_iff, length_pos_of_ne_nil]
. simp only [le_refl]
. apply Nat.succ_le.2
simp only [zero_le, ge_iff_le, nonpos_iff_eq_zero, ne_eq, h₂, not_false_iff, length_pos_of_ne_nil]
. simp only [tsub_le_iff_right, ge_iff_le, le_add_iff_nonneg_right]
. apply le_refl
| inr hinf =>
have hzero: length l₁ + 1 - length delim - length l₁ = 0 := by
simp only [tsub_le_iff_right, ge_iff_le, add_le_add_iff_left, zero_le, nonpos_iff_eq_zero,
tsub_eq_zero_iff_le]
apply Nat.succ_le_of_lt
simp only [zero_le, ge_iff_le, nonpos_iff_eq_zero, ne_eq, h₂, not_false_iff, length_pos_of_ne_nil]
rw [List.drop_append_eq_append_drop, hzero, drop] at hinf
have ⟨t, hinf⟩ := hinf
unfold lastN at h
exfalso
apply h
exists drop (length l₁ + 1 - length delim) s, t
convert hinf using 3
rw [Nat.sub_sub_eq_add_sub_of_le]
apply Nat.succ_le_of_lt
apply Nat.zero_lt_of_ne_zero
simp only [zero_le, ge_iff_le, nonpos_iff_eq_zero, ne_eq, length_eq_zero, h₂, not_false_iff] | case true
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case true
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | rw [List.take_append_of_le_length] at hinf <;> simp only [tsub_le_iff_right, ge_iff_le, le_add_iff_nonneg_right, zero_le, nonpos_iff_eq_zero] | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) l₁
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | have ⟨t, hinf⟩ := isPrefix_trans hinf take_isPrefix | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) l₁
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) l₁
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | rw [← hinf] | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
⊢ splitOnListAux delim (s ++ delim ++ t ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim (s ++ delim ++ t) #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | have hrw₁: s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂) := by simp only [append_assoc] | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
⊢ splitOnListAux delim (s ++ delim ++ t ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim (s ++ delim ++ t) #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
⊢ splitOnListAux delim (s ++ delim ++ t ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim (s ++ delim ++ t) #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
⊢ splitOnListAux delim (s ++ delim ++ t ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim (s ++ delim ++ t) #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | have hrw₂: s ++ delim ++ t = s ++ delim ++ t := by simp only [append_assoc] | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
⊢ splitOnListAux delim (s ++ delim ++ t ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim (s ++ delim ++ t) #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
⊢ splitOnListAux delim (s ++ delim ++ t ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim (s ++ delim ++ t) #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
⊢ splitOnListAux delim (s ++ delim ++ t ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim (s ++ delim ++ t) #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | rw [hrw₁, hrw₂, splitOnListAux_progress rgt, splitOnListAux_progress rgt] | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
⊢ splitOnListAux delim (s ++ delim ++ t ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim (s ++ delim ++ t) #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
⊢ #[toArray s] ++ splitOnListAux delim (t ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (#[toArray s] ++ splitOnListAux delim t #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
⊢ splitOnListAux delim (s ++ delim ++ t ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim (s ++ delim ++ t) #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | have _ : length t < length l₁ := by
apply_fun @List.length α at hinf
rw [← hinf, length_append, length_append]
apply Nat.lt_add_of_pos_left
apply Nat.add_pos_right
apply List.length_pos_of_ne_nil h₂ | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
⊢ #[toArray s] ++ splitOnListAux delim (t ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (#[toArray s] ++ splitOnListAux delim t #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
⊢ #[toArray s] ++ splitOnListAux delim (t ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (#[toArray s] ++ splitOnListAux delim t #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
⊢ #[toArray s] ++ splitOnListAux delim (t ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (#[toArray s] ++ splitOnListAux delim t #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | rw [List.splitOnListAux_append t] | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
⊢ #[toArray s] ++ splitOnListAux delim (t ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (#[toArray s] ++ splitOnListAux delim t #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
⊢ #[toArray s] ++ Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim t #[] #[] h₂) =
Array.modifyLast (fun x => x ++ toArray l₂) (#[toArray s] ++ splitOnListAux delim t #[] #[] h₂)
case true.inl.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
⊢ ¬delim <:+: lastN (length delim - 1) t ++ l₂
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
⊢ #[toArray s] ++ splitOnListAux delim (t ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (#[toArray s] ++ splitOnListAux delim t #[] #[] h₂)
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | . apply Array.ext'
simp only [Array.append_data, Array.data_toArray, Array.modifyLast_data, singleton_append]
cases h₃: (splitOnListAux delim t #[] #[] h₂).data with
| nil =>
exfalso
apply @splitOnListAux_ne_nil α delim #[] #[] h₂ _ t
apply Array.ext'
simp only [h₃, Array.data_toArray]
| cons head tail=> conv => right; rw [List.modifyLast_cons (List.cons_ne_nil head tail)] | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
⊢ #[toArray s] ++ Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim t #[] #[] h₂) =
Array.modifyLast (fun x => x ++ toArray l₂) (#[toArray s] ++ splitOnListAux delim t #[] #[] h₂)
case true.inl.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
⊢ ¬delim <:+: lastN (length delim - 1) t ++ l₂
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | case true.inl.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
⊢ ¬delim <:+: lastN (length delim - 1) t ++ l₂
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
⊢ #[toArray s] ++ Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim t #[] #[] h₂) =
Array.modifyLast (fun x => x ++ toArray l₂) (#[toArray s] ++ splitOnListAux delim t #[] #[] h₂)
case true.inl.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
⊢ ¬delim <:+: lastN (length delim - 1) t ++ l₂
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | . rw [← hinf] at h
intro contr
apply h
unfold lastN
unfold lastN at contr
rw [List.drop_append_eq_append_drop,List.drop_append_eq_append_drop]
simp only [append_assoc, length_append, tsub_le_iff_right, ge_iff_le, add_le_add_iff_left]
apply List.isInfix_append_left_of_isInfix
apply List.isInfix_append_left_of_isInfix
convert contr using 3
rw [ Nat.add_comm (length delim), ← Nat.add_assoc, Nat.add_sub_assoc, Nat.sub_sub_self, ←Nat.sub_sub,
Nat.add_comm (length s), Nat.add_assoc, Nat.add_comm (length s), ← Nat.add_assoc, Nat.add_sub_assoc, Nat.sub_self,
Nat.add_zero]
. rw [Nat.sub_sub_eq_add_sub_of_le]
apply Nat.succ_le.2
simp only [zero_le, ge_iff_le, nonpos_iff_eq_zero, ne_eq, h₂, not_false_iff, length_pos_of_ne_nil]
. simp only [le_refl]
. apply Nat.succ_le.2
simp only [zero_le, ge_iff_le, nonpos_iff_eq_zero, ne_eq, h₂, not_false_iff, length_pos_of_ne_nil]
. simp only [tsub_le_iff_right, ge_iff_le, le_add_iff_nonneg_right] | case true.inl.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
⊢ ¬delim <:+: lastN (length delim - 1) t ++ l₂
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inl.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
⊢ ¬delim <:+: lastN (length delim - 1) t ++ l₂
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | . apply le_refl | case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inl
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : s ++ delim <+: take (length l₁) (l₁ ++ l₂)
⊢ length l₁ ≤ length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | simp only [append_assoc] | α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
⊢ s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
⊢ s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | simp only [append_assoc] | α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
⊢ s ++ delim ++ t = s ++ delim ++ t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
⊢ s ++ delim ++ t = s ++ delim ++ t
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | apply_fun @List.length α at hinf | α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
⊢ length t < length l₁ | α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
hinf : length (s ++ delim ++ t) = length l₁
⊢ length t < length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
⊢ length t < length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | rw [← hinf, length_append, length_append] | α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
hinf : length (s ++ delim ++ t) = length l₁
⊢ length t < length l₁ | α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
hinf : length (s ++ delim ++ t) = length l₁
⊢ length t < length s + length delim + length t | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
hinf : length (s ++ delim ++ t) = length l₁
⊢ length t < length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | apply Nat.lt_add_of_pos_left | α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
hinf : length (s ++ delim ++ t) = length l₁
⊢ length t < length s + length delim + length t | case h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
hinf : length (s ++ delim ++ t) = length l₁
⊢ 0 < length s + length delim | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
hinf : length (s ++ delim ++ t) = length l₁
⊢ length t < length s + length delim + length t
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | apply Nat.add_pos_right | case h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
hinf : length (s ++ delim ++ t) = length l₁
⊢ 0 < length s + length delim | case h.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
hinf : length (s ++ delim ++ t) = length l₁
⊢ 0 < length delim | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
hinf : length (s ++ delim ++ t) = length l₁
⊢ 0 < length s + length delim
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | apply List.length_pos_of_ne_nil h₂ | case h.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
hinf : length (s ++ delim ++ t) = length l₁
⊢ 0 < length delim | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
hinf : length (s ++ delim ++ t) = length l₁
⊢ 0 < length delim
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | exfalso | case true.inl.h.nil
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
h₃ : (splitOnListAux delim t #[] #[] h₂).data = []
⊢ toArray s :: modifyLast (fun x => x ++ toArray l₂) [] = modifyLast (fun x => x ++ toArray l₂) [toArray s] | case true.inl.h.nil.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
h₃ : (splitOnListAux delim t #[] #[] h₂).data = []
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inl.h.nil
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
h₃ : (splitOnListAux delim t #[] #[] h₂).data = []
⊢ toArray s :: modifyLast (fun x => x ++ toArray l₂) [] = modifyLast (fun x => x ++ toArray l₂) [toArray s]
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | apply @splitOnListAux_ne_nil α delim #[] #[] h₂ _ t | case true.inl.h.nil.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
h₃ : (splitOnListAux delim t #[] #[] h₂).data = []
⊢ False | case true.inl.h.nil.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
h₃ : (splitOnListAux delim t #[] #[] h₂).data = []
⊢ splitOnListAux delim t #[] #[] h₂ = #[] | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inl.h.nil.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
h₃ : (splitOnListAux delim t #[] #[] h₂).data = []
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | apply Array.ext' | case true.inl.h.nil.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
h₃ : (splitOnListAux delim t #[] #[] h₂).data = []
⊢ splitOnListAux delim t #[] #[] h₂ = #[] | case true.inl.h.nil.h.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
h₃ : (splitOnListAux delim t #[] #[] h₂).data = []
⊢ (splitOnListAux delim t #[] #[] h₂).data = #[].data | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inl.h.nil.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
h₃ : (splitOnListAux delim t #[] #[] h₂).data = []
⊢ splitOnListAux delim t #[] #[] h₂ = #[]
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | simp only [h₃, Array.data_toArray] | case true.inl.h.nil.h.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
h₃ : (splitOnListAux delim t #[] #[] h₂).data = []
⊢ (splitOnListAux delim t #[] #[] h₂).data = #[].data | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inl.h.nil.h.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
h₃ : (splitOnListAux delim t #[] #[] h₂).data = []
⊢ (splitOnListAux delim t #[] #[] h₂).data = #[].data
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | conv => right; rw [List.modifyLast_cons (List.cons_ne_nil head tail)] | case true.inl.h.cons
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
head : Array α
tail : List (Array α)
h₃ : (splitOnListAux delim t #[] #[] h₂).data = head :: tail
⊢ toArray s :: modifyLast (fun x => x ++ toArray l₂) (head :: tail) =
modifyLast (fun x => x ++ toArray l₂) (toArray s :: head :: tail) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inl.h.cons
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : s ++ delim <+: take (length l₁) l₁
t : List α
hinf : s ++ delim ++ t = l₁
hrw₁ : s ++ delim ++ t ++ l₂ = s ++ delim ++ (t ++ l₂)
hrw₂ : s ++ delim ++ t = s ++ delim ++ t
x✝ : length t < length l₁
head : Array α
tail : List (Array α)
h₃ : (splitOnListAux delim t #[] #[] h₂).data = head :: tail
⊢ toArray s :: modifyLast (fun x => x ++ toArray l₂) (head :: tail) =
modifyLast (fun x => x ++ toArray l₂) (toArray s :: head :: tail)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | have hzero: length l₁ + 1 - length delim - length l₁ = 0 := by
simp only [tsub_le_iff_right, ge_iff_le, add_le_add_iff_left, zero_le, nonpos_iff_eq_zero,
tsub_eq_zero_iff_le]
apply Nat.succ_le_of_lt
simp only [zero_le, ge_iff_le, nonpos_iff_eq_zero, ne_eq, h₂, not_false_iff, length_pos_of_ne_nil] | case true.inr
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) (l₁ ++ l₂)
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | case true.inr
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) (l₁ ++ l₂)
hzero : length l₁ + 1 - length delim - length l₁ = 0
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inr
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) (l₁ ++ l₂)
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | rw [List.drop_append_eq_append_drop, hzero, drop] at hinf | case true.inr
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) (l₁ ++ l₂)
hzero : length l₁ + 1 - length delim - length l₁ = 0
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | case true.inr
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inr
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) (l₁ ++ l₂)
hzero : length l₁ + 1 - length delim - length l₁ = 0
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | have ⟨t, hinf⟩ := hinf | case true.inr
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | case true.inr
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inr
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | unfold lastN at h | case true.inr
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | case true.inr
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inr
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | exfalso | case true.inr
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | case true.inr.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inr
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | apply h | case true.inr.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ False | case true.inr.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂ | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inr.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | exists drop (length l₁ + 1 - length delim) s, t | case true.inr.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂ | case true.inr.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ - (length delim - 1)) l₁ ++ l₂ | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inr.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | convert hinf using 3 | case true.inr.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ - (length delim - 1)) l₁ ++ l₂ | case e_a.e_a.e_a
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ length l₁ - (length delim - 1) = length l₁ + 1 - length delim | Please generate a tactic in lean4 to solve the state.
STATE:
case true.inr.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ - (length delim - 1)) l₁ ++ l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | rw [Nat.sub_sub_eq_add_sub_of_le] | case e_a.e_a.e_a
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ length l₁ - (length delim - 1) = length l₁ + 1 - length delim | case e_a.e_a.e_a
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ 1 ≤ length delim | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.e_a.e_a
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ length l₁ - (length delim - 1) = length l₁ + 1 - length delim
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | apply Nat.succ_le_of_lt | case e_a.e_a.e_a
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ 1 ≤ length delim | case e_a.e_a.e_a.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ 0 < length delim | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.e_a.e_a
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ 1 ≤ length delim
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | apply Nat.zero_lt_of_ne_zero | case e_a.e_a.e_a.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ 0 < length delim | case e_a.e_a.e_a.h.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ length delim ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.e_a.e_a.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ 0 < length delim
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | simp only [zero_le, ge_iff_le, nonpos_iff_eq_zero, ne_eq, length_eq_zero, h₂, not_false_iff] | case e_a.e_a.e_a.h.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ length delim ≠ 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.e_a.e_a.h.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: drop (length l₁ - (length delim - 1)) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf✝ : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) l₁ ++ l₂
hzero : length l₁ + 1 - length delim - length l₁ = 0
t : List α
hinf : drop (length l₁ + 1 - length delim) s ++ delim ++ t = drop (length l₁ + 1 - length delim) l₁ ++ l₂
⊢ length delim ≠ 0
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | simp only [tsub_le_iff_right, ge_iff_le, add_le_add_iff_left, zero_le, nonpos_iff_eq_zero,
tsub_eq_zero_iff_le] | α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) (l₁ ++ l₂)
⊢ length l₁ + 1 - length delim - length l₁ = 0 | α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) (l₁ ++ l₂)
⊢ 1 ≤ length delim | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) (l₁ ++ l₂)
⊢ length l₁ + 1 - length delim - length l₁ = 0
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | apply Nat.succ_le_of_lt | α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) (l₁ ++ l₂)
⊢ 1 ≤ length delim | case h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) (l₁ ++ l₂)
⊢ 0 < length delim | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) (l₁ ++ l₂)
⊢ 1 ≤ length delim
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | simp only [zero_le, ge_iff_le, nonpos_iff_eq_zero, ne_eq, h₂, not_false_iff, length_pos_of_ne_nil] | case h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) (l₁ ++ l₂)
⊢ 0 < length delim | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : delim <:+: l₁ ++ l₂
s : List α
lft : s ++ delim <+: l₁ ++ l₂
rgt : ¬delim <:+: s ++ dropLast delim
hinf : drop (length l₁ + 1 - length delim) s ++ delim <+: drop (length l₁ + 1 - length delim) (l₁ ++ l₂)
⊢ 0 < length delim
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | rw [← Bool.not_eq_true, isInfixOf_ext] at heq | case false
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : isInfixOf delim (l₁ ++ l₂) = false
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | case false
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | Please generate a tactic in lean4 to solve the state.
STATE:
case false
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : isInfixOf delim (l₁ ++ l₂) = false
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | have not_in_l₁: ¬ delim <:+: l₁ := by
intro contr;
apply heq
apply List.isInfix_append_right_of_isInfix contr | case false
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | case false
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
not_in_l₁ : ¬delim <:+: l₁
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | Please generate a tactic in lean4 to solve the state.
STATE:
case false
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | rw [splitOnListAux_nonmatching _ heq, splitOnListAux_nonmatching _ not_in_l₁] | case false
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
not_in_l₁ : ¬delim <:+: l₁
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂) | case false
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
not_in_l₁ : ¬delim <:+: l₁
⊢ #[toArray (l₁ ++ l₂)] = Array.modifyLast (fun x => x ++ toArray l₂) #[toArray l₁] | Please generate a tactic in lean4 to solve the state.
STATE:
case false
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
not_in_l₁ : ¬delim <:+: l₁
⊢ splitOnListAux delim (l₁ ++ l₂) #[] #[] h₂ =
Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux delim l₁ #[] #[] h₂)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | apply Array.ext' | case false
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
not_in_l₁ : ¬delim <:+: l₁
⊢ #[toArray (l₁ ++ l₂)] = Array.modifyLast (fun x => x ++ toArray l₂) #[toArray l₁] | case false.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
not_in_l₁ : ¬delim <:+: l₁
⊢ #[toArray (l₁ ++ l₂)].data = (Array.modifyLast (fun x => x ++ toArray l₂) #[toArray l₁]).data | Please generate a tactic in lean4 to solve the state.
STATE:
case false
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
not_in_l₁ : ¬delim <:+: l₁
⊢ #[toArray (l₁ ++ l₂)] = Array.modifyLast (fun x => x ++ toArray l₂) #[toArray l₁]
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | simp only [Array.data_toArray, Array.modifyLast_data, modifyLast_singleton, cons.injEq, and_true] | case false.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
not_in_l₁ : ¬delim <:+: l₁
⊢ #[toArray (l₁ ++ l₂)].data = (Array.modifyLast (fun x => x ++ toArray l₂) #[toArray l₁]).data | case false.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
not_in_l₁ : ¬delim <:+: l₁
⊢ toArray (l₁ ++ l₂) = toArray l₁ ++ toArray l₂ | Please generate a tactic in lean4 to solve the state.
STATE:
case false.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
not_in_l₁ : ¬delim <:+: l₁
⊢ #[toArray (l₁ ++ l₂)].data = (Array.modifyLast (fun x => x ++ toArray l₂) #[toArray l₁]).data
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | apply Array.ext' | case false.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
not_in_l₁ : ¬delim <:+: l₁
⊢ toArray (l₁ ++ l₂) = toArray l₁ ++ toArray l₂ | case false.h.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
not_in_l₁ : ¬delim <:+: l₁
⊢ (toArray (l₁ ++ l₂)).data = (toArray l₁ ++ toArray l₂).data | Please generate a tactic in lean4 to solve the state.
STATE:
case false.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
not_in_l₁ : ¬delim <:+: l₁
⊢ toArray (l₁ ++ l₂) = toArray l₁ ++ toArray l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | simp only [Array.data_toArray, Array.append_data] | case false.h.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
not_in_l₁ : ¬delim <:+: l₁
⊢ (toArray (l₁ ++ l₂)).data = (toArray l₁ ++ toArray l₂).data | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case false.h.h
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
not_in_l₁ : ¬delim <:+: l₁
⊢ (toArray (l₁ ++ l₂)).data = (toArray l₁ ++ toArray l₂).data
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | intro contr | α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
⊢ ¬delim <:+: l₁ | α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
contr : delim <:+: l₁
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
⊢ ¬delim <:+: l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | apply heq | α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
contr : delim <:+: l₁
⊢ False | α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
contr : delim <:+: l₁
⊢ delim <:+: l₁ ++ l₂ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
contr : delim <:+: l₁
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnListAux_append | [1693, 1] | [1775, 55] | apply List.isInfix_append_right_of_isInfix contr | α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
contr : delim <:+: l₁
⊢ delim <:+: l₁ ++ l₂ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
h₂ : delim ≠ []
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
heq : ¬delim <:+: l₁ ++ l₂
contr : delim <:+: l₁
⊢ delim <:+: l₁ ++ l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.map_modifyLast | [1777, 1] | [1782, 69] | if heq: l = [] then
simp only [heq, map, modifyLast_nil]
else
rw [← List.dropLast_append_getLast heq, List.modifyLast_append_one, map_append, map_append,
map_singleton, map_singleton,List.modifyLast_append_one, P.eq] | α✝ : Type u_1
β✝ : Type u_2
f : α✝ → β✝
h : α✝ → α✝
g : β✝ → β✝
l : List α✝
P : Function.Semiconj f h g
⊢ map f (modifyLast h l) = modifyLast g (map f l) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
β✝ : Type u_2
f : α✝ → β✝
h : α✝ → α✝
g : β✝ → β✝
l : List α✝
P : Function.Semiconj f h g
⊢ map f (modifyLast h l) = modifyLast g (map f l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.map_modifyLast | [1777, 1] | [1782, 69] | simp only [heq, map, modifyLast_nil] | α✝ : Type u_1
β✝ : Type u_2
f : α✝ → β✝
h : α✝ → α✝
g : β✝ → β✝
l : List α✝
P : Function.Semiconj f h g
heq : l = []
⊢ map f (modifyLast h l) = modifyLast g (map f l) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
β✝ : Type u_2
f : α✝ → β✝
h : α✝ → α✝
g : β✝ → β✝
l : List α✝
P : Function.Semiconj f h g
heq : l = []
⊢ map f (modifyLast h l) = modifyLast g (map f l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.map_modifyLast | [1777, 1] | [1782, 69] | rw [← List.dropLast_append_getLast heq, List.modifyLast_append_one, map_append, map_append,
map_singleton, map_singleton,List.modifyLast_append_one, P.eq] | α✝ : Type u_1
β✝ : Type u_2
f : α✝ → β✝
h : α✝ → α✝
g : β✝ → β✝
l : List α✝
P : Function.Semiconj f h g
heq : ¬l = []
⊢ map f (modifyLast h l) = modifyLast g (map f l) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
β✝ : Type u_2
f : α✝ → β✝
h : α✝ → α✝
g : β✝ → β✝
l : List α✝
P : Function.Semiconj f h g
heq : ¬l = []
⊢ map f (modifyLast h l) = modifyLast g (map f l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.map_dropLast | [1784, 1] | [1785, 53] | simp only [dropLast_eq_take, map_take, length_map] | α✝¹ : Type u_1
α✝ : Type u_2
f : α✝¹ → α✝
l : List α✝¹
⊢ map f (dropLast l) = dropLast (map f l) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝¹ : Type u_1
α✝ : Type u_2
f : α✝¹ → α✝
l : List α✝¹
⊢ map f (dropLast l) = dropLast (map f l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Int.not_newline_mem_reprΔ | [1788, 1] | [1802, 19] | unfold reprΔ | n : ℤ
⊢ ¬Char.ofNat 10 ∈ reprΔ n | n : ℤ
⊢ ¬Char.ofNat 10 ∈
match n with
| ofNat m => Nat.toDigits 10 m
| -[m+1] => [Char.ofNat 45] ++ Nat.toDigits 10 (Nat.succ m) | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℤ
⊢ ¬Char.ofNat 10 ∈ reprΔ n
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Int.not_newline_mem_reprΔ | [1788, 1] | [1802, 19] | intro contr | n : ℤ
⊢ ¬Char.ofNat 10 ∈
match n with
| ofNat m => Nat.toDigits 10 m
| -[m+1] => [Char.ofNat 45] ++ Nat.toDigits 10 (Nat.succ m) | n : ℤ
contr :
Char.ofNat 10 ∈
match n with
| ofNat m => Nat.toDigits 10 m
| -[m+1] => [Char.ofNat 45] ++ Nat.toDigits 10 (Nat.succ m)
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℤ
⊢ ¬Char.ofNat 10 ∈
match n with
| ofNat m => Nat.toDigits 10 m
| -[m+1] => [Char.ofNat 45] ++ Nat.toDigits 10 (Nat.succ m)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Int.not_newline_mem_reprΔ | [1788, 1] | [1802, 19] | split at contr | n : ℤ
contr :
Char.ofNat 10 ∈
match n with
| ofNat m => Nat.toDigits 10 m
| -[m+1] => [Char.ofNat 45] ++ Nat.toDigits 10 (Nat.succ m)
⊢ False | case h_1
i✝ : ℤ
m✝ : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 m✝
⊢ False
case h_2
i✝ : ℤ
m✝ : ℕ
contr : Char.ofNat 10 ∈ [Char.ofNat 45] ++ Nat.toDigits 10 (Nat.succ m✝)
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℤ
contr :
Char.ofNat 10 ∈
match n with
| ofNat m => Nat.toDigits 10 m
| -[m+1] => [Char.ofNat 45] ++ Nat.toDigits 10 (Nat.succ m)
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Int.not_newline_mem_reprΔ | [1788, 1] | [1802, 19] | case h_1 n =>
have isdig := Nat.toDigits_digits 10 n
simp only [beq_iff_eq, List.all_eq_true, forall_true_left] at isdig
have h := isdig '\n' contr
simp only at h | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 n
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 n
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Int.not_newline_mem_reprΔ | [1788, 1] | [1802, 19] | case h_2 n =>
simp only [List.singleton_append, List.find?, List.mem_cons, false_or] at contr
have isdig := Nat.toDigits_digits 10 (Nat.succ n)
simp only [beq_iff_eq, List.all_eq_true, forall_true_left] at isdig
have h := isdig '\n' contr
simp only at h | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ [Char.ofNat 45] ++ Nat.toDigits 10 (Nat.succ n)
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ [Char.ofNat 45] ++ Nat.toDigits 10 (Nat.succ n)
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Int.not_newline_mem_reprΔ | [1788, 1] | [1802, 19] | have isdig := Nat.toDigits_digits 10 n | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 n
⊢ False | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 n
isdig : 10 ≤ 10 → 10 > 1 → (List.all (Nat.toDigits 10 n) Char.isDigit == true) = true
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 n
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Int.not_newline_mem_reprΔ | [1788, 1] | [1802, 19] | simp only [beq_iff_eq, List.all_eq_true, forall_true_left] at isdig | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 n
isdig : 10 ≤ 10 → 10 > 1 → (List.all (Nat.toDigits 10 n) Char.isDigit == true) = true
⊢ False | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 n
isdig : ∀ (x : Char), x ∈ Nat.toDigits 10 n → Char.isDigit x = true
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 n
isdig : 10 ≤ 10 → 10 > 1 → (List.all (Nat.toDigits 10 n) Char.isDigit == true) = true
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Int.not_newline_mem_reprΔ | [1788, 1] | [1802, 19] | have h := isdig '\n' contr | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 n
isdig : ∀ (x : Char), x ∈ Nat.toDigits 10 n → Char.isDigit x = true
⊢ False | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 n
isdig : ∀ (x : Char), x ∈ Nat.toDigits 10 n → Char.isDigit x = true
h : Char.isDigit (Char.ofNat 10) = true
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 n
isdig : ∀ (x : Char), x ∈ Nat.toDigits 10 n → Char.isDigit x = true
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Int.not_newline_mem_reprΔ | [1788, 1] | [1802, 19] | simp only at h | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 n
isdig : ∀ (x : Char), x ∈ Nat.toDigits 10 n → Char.isDigit x = true
h : Char.isDigit (Char.ofNat 10) = true
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 n
isdig : ∀ (x : Char), x ∈ Nat.toDigits 10 n → Char.isDigit x = true
h : Char.isDigit (Char.ofNat 10) = true
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Int.not_newline_mem_reprΔ | [1788, 1] | [1802, 19] | simp only [List.singleton_append, List.find?, List.mem_cons, false_or] at contr | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ [Char.ofNat 45] ++ Nat.toDigits 10 (Nat.succ n)
⊢ False | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 (Nat.succ n)
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ [Char.ofNat 45] ++ Nat.toDigits 10 (Nat.succ n)
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Int.not_newline_mem_reprΔ | [1788, 1] | [1802, 19] | have isdig := Nat.toDigits_digits 10 (Nat.succ n) | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 (Nat.succ n)
⊢ False | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 (Nat.succ n)
isdig : 10 ≤ 10 → 10 > 1 → (List.all (Nat.toDigits 10 (Nat.succ n)) Char.isDigit == true) = true
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 (Nat.succ n)
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Int.not_newline_mem_reprΔ | [1788, 1] | [1802, 19] | simp only [beq_iff_eq, List.all_eq_true, forall_true_left] at isdig | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 (Nat.succ n)
isdig : 10 ≤ 10 → 10 > 1 → (List.all (Nat.toDigits 10 (Nat.succ n)) Char.isDigit == true) = true
⊢ False | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 (Nat.succ n)
isdig : ∀ (x : Char), x ∈ Nat.toDigits 10 (Nat.succ n) → Char.isDigit x = true
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 (Nat.succ n)
isdig : 10 ≤ 10 → 10 > 1 → (List.all (Nat.toDigits 10 (Nat.succ n)) Char.isDigit == true) = true
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Int.not_newline_mem_reprΔ | [1788, 1] | [1802, 19] | have h := isdig '\n' contr | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 (Nat.succ n)
isdig : ∀ (x : Char), x ∈ Nat.toDigits 10 (Nat.succ n) → Char.isDigit x = true
⊢ False | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 (Nat.succ n)
isdig : ∀ (x : Char), x ∈ Nat.toDigits 10 (Nat.succ n) → Char.isDigit x = true
h : Char.isDigit (Char.ofNat 10) = true
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 (Nat.succ n)
isdig : ∀ (x : Char), x ∈ Nat.toDigits 10 (Nat.succ n) → Char.isDigit x = true
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Int.not_newline_mem_reprΔ | [1788, 1] | [1802, 19] | simp only at h | i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 (Nat.succ n)
isdig : ∀ (x : Char), x ∈ Nat.toDigits 10 (Nat.succ n) → Char.isDigit x = true
h : Char.isDigit (Char.ofNat 10) = true
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i✝ : ℤ
n : ℕ
contr : Char.ofNat 10 ∈ Nat.toDigits 10 (Nat.succ n)
isdig : ∀ (x : Char), x ∈ Nat.toDigits 10 (Nat.succ n) → Char.isDigit x = true
h : Char.isDigit (Char.ofNat 10) = true
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnList_append | [1804, 1] | [1815, 87] | unfold splitOnList | α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
⊢ splitOnList delim (l₁ ++ l₂) = modifyLast (fun x => x ++ l₂) (splitOnList delim l₁) | α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
⊢ (match delim with
| [] => [l₁ ++ l₂]
| head :: tail =>
Array.toList
(Array.map Array.toList (splitOnListAux (head :: tail) (l₁ ++ l₂) #[] #[] (_ : ¬head :: tail = [])))) =
modifyLast (fun x => x ++ l₂)
(match delim with
| [] => [l₁]
| head :: tail =>
Array.toList (Array.map Array.toList (splitOnListAux (head :: tail) l₁ #[] #[] (_ : ¬head :: tail = [])))) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
⊢ splitOnList delim (l₁ ++ l₂) = modifyLast (fun x => x ++ l₂) (splitOnList delim l₁)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnList_append | [1804, 1] | [1815, 87] | match delim with
| [] => simp only [modifyLast_singleton]
| hd::tl =>
simp only [Array.toList_eq, Array.map_data]
rw [List.splitOnListAux_append _ _ h]
rw [← map_modifyLast]
. rw [Array.modifyLast_data]
. unfold Function.Semiconj
simp only [Array.toList_eq, Array.append_data, Array.data_toArray, forall_const] | α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
⊢ (match delim with
| [] => [l₁ ++ l₂]
| head :: tail =>
Array.toList
(Array.map Array.toList (splitOnListAux (head :: tail) (l₁ ++ l₂) #[] #[] (_ : ¬head :: tail = [])))) =
modifyLast (fun x => x ++ l₂)
(match delim with
| [] => [l₁]
| head :: tail =>
Array.toList (Array.map Array.toList (splitOnListAux (head :: tail) l₁ #[] #[] (_ : ¬head :: tail = [])))) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬delim <:+: lastN (length delim - 1) l₁ ++ l₂
⊢ (match delim with
| [] => [l₁ ++ l₂]
| head :: tail =>
Array.toList
(Array.map Array.toList (splitOnListAux (head :: tail) (l₁ ++ l₂) #[] #[] (_ : ¬head :: tail = [])))) =
modifyLast (fun x => x ++ l₂)
(match delim with
| [] => [l₁]
| head :: tail =>
Array.toList (Array.map Array.toList (splitOnListAux (head :: tail) l₁ #[] #[] (_ : ¬head :: tail = []))))
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnList_append | [1804, 1] | [1815, 87] | simp only [modifyLast_singleton] | α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬[] <:+: lastN (length [] - 1) l₁ ++ l₂
⊢ (match [] with
| [] => [l₁ ++ l₂]
| head :: tail =>
Array.toList
(Array.map Array.toList (splitOnListAux (head :: tail) (l₁ ++ l₂) #[] #[] (_ : ¬head :: tail = [])))) =
modifyLast (fun x => x ++ l₂)
(match [] with
| [] => [l₁]
| head :: tail =>
Array.toList (Array.map Array.toList (splitOnListAux (head :: tail) l₁ #[] #[] (_ : ¬head :: tail = [])))) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ¬[] <:+: lastN (length [] - 1) l₁ ++ l₂
⊢ (match [] with
| [] => [l₁ ++ l₂]
| head :: tail =>
Array.toList
(Array.map Array.toList (splitOnListAux (head :: tail) (l₁ ++ l₂) #[] #[] (_ : ¬head :: tail = [])))) =
modifyLast (fun x => x ++ l₂)
(match [] with
| [] => [l₁]
| head :: tail =>
Array.toList (Array.map Array.toList (splitOnListAux (head :: tail) l₁ #[] #[] (_ : ¬head :: tail = []))))
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnList_append | [1804, 1] | [1815, 87] | simp only [Array.toList_eq, Array.map_data] | α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ (match hd :: tl with
| [] => [l₁ ++ l₂]
| head :: tail =>
Array.toList
(Array.map Array.toList (splitOnListAux (head :: tail) (l₁ ++ l₂) #[] #[] (_ : ¬head :: tail = [])))) =
modifyLast (fun x => x ++ l₂)
(match hd :: tl with
| [] => [l₁]
| head :: tail =>
Array.toList (Array.map Array.toList (splitOnListAux (head :: tail) l₁ #[] #[] (_ : ¬head :: tail = [])))) | α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ map Array.toList (splitOnListAux (hd :: tl) (l₁ ++ l₂) #[] #[] (_ : ¬hd :: tl = [])).data =
modifyLast (fun x => x ++ l₂) (map Array.toList (splitOnListAux (hd :: tl) l₁ #[] #[] (_ : ¬hd :: tl = [])).data) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ (match hd :: tl with
| [] => [l₁ ++ l₂]
| head :: tail =>
Array.toList
(Array.map Array.toList (splitOnListAux (head :: tail) (l₁ ++ l₂) #[] #[] (_ : ¬head :: tail = [])))) =
modifyLast (fun x => x ++ l₂)
(match hd :: tl with
| [] => [l₁]
| head :: tail =>
Array.toList (Array.map Array.toList (splitOnListAux (head :: tail) l₁ #[] #[] (_ : ¬head :: tail = []))))
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnList_append | [1804, 1] | [1815, 87] | rw [List.splitOnListAux_append _ _ h] | α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ map Array.toList (splitOnListAux (hd :: tl) (l₁ ++ l₂) #[] #[] (_ : ¬hd :: tl = [])).data =
modifyLast (fun x => x ++ l₂) (map Array.toList (splitOnListAux (hd :: tl) l₁ #[] #[] (_ : ¬hd :: tl = [])).data) | α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ map Array.toList
(Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux (hd :: tl) l₁ #[] #[] (_ : ¬hd :: tl = []))).data =
modifyLast (fun x => x ++ l₂) (map Array.toList (splitOnListAux (hd :: tl) l₁ #[] #[] (_ : ¬hd :: tl = [])).data) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ map Array.toList (splitOnListAux (hd :: tl) (l₁ ++ l₂) #[] #[] (_ : ¬hd :: tl = [])).data =
modifyLast (fun x => x ++ l₂) (map Array.toList (splitOnListAux (hd :: tl) l₁ #[] #[] (_ : ¬hd :: tl = [])).data)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnList_append | [1804, 1] | [1815, 87] | rw [← map_modifyLast] | α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ map Array.toList
(Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux (hd :: tl) l₁ #[] #[] (_ : ¬hd :: tl = []))).data =
modifyLast (fun x => x ++ l₂) (map Array.toList (splitOnListAux (hd :: tl) l₁ #[] #[] (_ : ¬hd :: tl = [])).data) | α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ map Array.toList
(Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux (hd :: tl) l₁ #[] #[] (_ : ¬hd :: tl = []))).data =
map Array.toList (modifyLast ?m.340731 (splitOnListAux (hd :: tl) l₁ #[] #[] (_ : ¬hd :: tl = [])).data)
α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ Function.Semiconj Array.toList ?m.340731 fun x => x ++ l₂
α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ Array α → Array α | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ map Array.toList
(Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux (hd :: tl) l₁ #[] #[] (_ : ¬hd :: tl = []))).data =
modifyLast (fun x => x ++ l₂) (map Array.toList (splitOnListAux (hd :: tl) l₁ #[] #[] (_ : ¬hd :: tl = [])).data)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnList_append | [1804, 1] | [1815, 87] | . rw [Array.modifyLast_data] | α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ map Array.toList
(Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux (hd :: tl) l₁ #[] #[] (_ : ¬hd :: tl = []))).data =
map Array.toList (modifyLast ?m.340731 (splitOnListAux (hd :: tl) l₁ #[] #[] (_ : ¬hd :: tl = [])).data)
α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ Function.Semiconj Array.toList ?m.340731 fun x => x ++ l₂
α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ Array α → Array α | α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ Function.Semiconj Array.toList (fun x => x ++ toArray l₂) fun x => x ++ l₂ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ map Array.toList
(Array.modifyLast (fun x => x ++ toArray l₂) (splitOnListAux (hd :: tl) l₁ #[] #[] (_ : ¬hd :: tl = []))).data =
map Array.toList (modifyLast ?m.340731 (splitOnListAux (hd :: tl) l₁ #[] #[] (_ : ¬hd :: tl = [])).data)
α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ Function.Semiconj Array.toList ?m.340731 fun x => x ++ l₂
α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ Array α → Array α
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnList_append | [1804, 1] | [1815, 87] | . unfold Function.Semiconj
simp only [Array.toList_eq, Array.append_data, Array.data_toArray, forall_const] | α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ Function.Semiconj Array.toList (fun x => x ++ toArray l₂) fun x => x ++ l₂ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
hd : α
tl : List α
h : ¬hd :: tl <:+: lastN (length (hd :: tl) - 1) l₁ ++ l₂
⊢ Function.Semiconj Array.toList (fun x => x ++ toArray l₂) fun x => x ++ l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyHead_eq_modifyNth | [1817, 1] | [1818, 51] | simp only [modifyNth, modifyHead, modifyNthTail] | α : Type u_1
f : α → α
l : List α
⊢ modifyHead f l = modifyNth f 0 l | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
f : α → α
l : List α
⊢ modifyHead f l = modifyNth f 0 l
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_ge_length | [1820, 1] | [1822, 59] | simp only [modifyNth_eq_set_get?, zero_le, ge_iff_le, nonpos_iff_eq_zero, List.get?_eq_none.2 h,
Option.map_eq_map, Option.map_none', Option.getD_none] | α✝ : Type u_1
l : List α✝
i : ℕ
f : α✝ → α✝
h : length l ≤ i
⊢ modifyNth f i l = l | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
l : List α✝
i : ℕ
f : α✝ → α✝
h : length l ≤ i
⊢ modifyNth f i l = l
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_ne | [1824, 1] | [1839, 56] | if h₁: i < length l then
if h₂: j < length l then
rw [List.modifyNth_eq_set_get _ h₁, List.modifyNth_eq_set_get _ h₂, List.modifyNth_eq_set_get, List.modifyNth_eq_set_get,
set_comm, get_set_ne, get_set_ne] <;>
simp only [h, h₁, h₂, ne_eq, not_false_iff,length_set]
. apply Ne.symm h
. apply Ne.symm h
else
simp only [not_lt] at h₂
have h₃: length (modifyNth f i l) ≤ j := by simp only [modify_get?_length, h₂]
rw [modifyNth_ge_length h₂, modifyNth_ge_length h₃]
else
simp only [not_lt] at h₁
have h₃: length (modifyNth g j l) ≤ i := by simp only [modify_get?_length, h₁]
rw [modifyNth_ge_length h₁, modifyNth_ge_length h₃] | i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.