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.modifyNth_modifyNth_ne | [1824, 1] | [1839, 56] | 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₃] | i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
⊢ 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
h₁ : i < length l
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_ne | [1824, 1] | [1839, 56] | 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] | i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : j < length l
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l) | case h
i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : j < length l
⊢ ¬j = i
case a
i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : j < length l
⊢ ¬j = i | Please generate a tactic in lean4 to solve the state.
STATE:
i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : j < length l
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_ne | [1824, 1] | [1839, 56] | . apply Ne.symm h | case h
i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : j < length l
⊢ ¬j = i
case a
i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : j < length l
⊢ ¬j = i | case a
i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : j < length l
⊢ ¬j = i | Please generate a tactic in lean4 to solve the state.
STATE:
case h
i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : j < length l
⊢ ¬j = i
case a
i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : j < length l
⊢ ¬j = i
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_ne | [1824, 1] | [1839, 56] | . apply Ne.symm h | case a
i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : j < length l
⊢ ¬j = i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : j < length l
⊢ ¬j = i
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_ne | [1824, 1] | [1839, 56] | simp only [not_lt] at h₂ | i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : ¬j < length l
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l) | i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : length l ≤ j
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l) | Please generate a tactic in lean4 to solve the state.
STATE:
i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : ¬j < length l
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_ne | [1824, 1] | [1839, 56] | have h₃: length (modifyNth f i l) ≤ j := by simp only [modify_get?_length, h₂] | i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : length l ≤ j
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l) | i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : length l ≤ j
h₃ : length (modifyNth f i l) ≤ j
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l) | Please generate a tactic in lean4 to solve the state.
STATE:
i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : length l ≤ j
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_ne | [1824, 1] | [1839, 56] | rw [modifyNth_ge_length h₂, modifyNth_ge_length h₃] | i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : length l ≤ j
h₃ : length (modifyNth f i l) ≤ 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
h₁ : i < length l
h₂ : length l ≤ j
h₃ : length (modifyNth f i l) ≤ j
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_ne | [1824, 1] | [1839, 56] | simp only [modify_get?_length, h₂] | i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : i < length l
h₂ : length l ≤ j
⊢ length (modifyNth f i l) ≤ j | 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
h₁ : i < length l
h₂ : length l ≤ j
⊢ length (modifyNth f i l) ≤ j
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_ne | [1824, 1] | [1839, 56] | simp only [not_lt] at h₁ | i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : ¬i < length l
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l) | i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : length l ≤ i
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l) | Please generate a tactic in lean4 to solve the state.
STATE:
i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : ¬i < length l
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_ne | [1824, 1] | [1839, 56] | have h₃: length (modifyNth g j l) ≤ i := by simp only [modify_get?_length, h₁] | i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : length l ≤ i
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l) | i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : length l ≤ i
h₃ : length (modifyNth g j l) ≤ i
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l) | Please generate a tactic in lean4 to solve the state.
STATE:
i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : length l ≤ i
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_ne | [1824, 1] | [1839, 56] | rw [modifyNth_ge_length h₁, modifyNth_ge_length h₃] | i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : length l ≤ i
h₃ : length (modifyNth g j l) ≤ i
⊢ 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
h₁ : length l ≤ i
h₃ : length (modifyNth g j l) ≤ i
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_ne | [1824, 1] | [1839, 56] | simp only [modify_get?_length, h₁] | i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i ≠ j
h₁ : length l ≤ i
⊢ length (modifyNth g j l) ≤ i | 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
h₁ : length l ≤ i
⊢ length (modifyNth g j l) ≤ i
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.set_set | [1842, 1] | [1848, 24] | subst j | i j : ℕ
α✝ : Type u_1
l : List α✝
b a : α✝
h : i = j
⊢ set (set l j b) i a = set l i a | i : ℕ
α✝ : Type u_1
l : List α✝
b a : α✝
⊢ set (set l i b) i a = set l i a | Please generate a tactic in lean4 to solve the state.
STATE:
i j : ℕ
α✝ : Type u_1
l : List α✝
b a : α✝
h : i = j
⊢ set (set l j b) i a = set l i a
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.set_set | [1842, 1] | [1848, 24] | apply List.ext_get | i : ℕ
α✝ : Type u_1
l : List α✝
b a : α✝
⊢ set (set l i b) i a = set l i a | case hl
i : ℕ
α✝ : Type u_1
l : List α✝
b a : α✝
⊢ length (set (set l i b) i a) = length (set l i a)
case h
i : ℕ
α✝ : Type u_1
l : List α✝
b a : α✝
⊢ ∀ (n : ℕ) (h₁ : n < length (set (set l i b) i a)) (h₂ : n < length (set l i a)),
get (set (set l i b) i a) { val := n, isLt := h₁ } = get (set l i a) { val := n, isLt := h₂ } | Please generate a tactic in lean4 to solve the state.
STATE:
i : ℕ
α✝ : Type u_1
l : List α✝
b a : α✝
⊢ set (set l i b) i a = set l i a
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.set_set | [1842, 1] | [1848, 24] | . simp only [length_set] | case hl
i : ℕ
α✝ : Type u_1
l : List α✝
b a : α✝
⊢ length (set (set l i b) i a) = length (set l i a)
case h
i : ℕ
α✝ : Type u_1
l : List α✝
b a : α✝
⊢ ∀ (n : ℕ) (h₁ : n < length (set (set l i b) i a)) (h₂ : n < length (set l i a)),
get (set (set l i b) i a) { val := n, isLt := h₁ } = get (set l i a) { val := n, isLt := h₂ } | case h
i : ℕ
α✝ : Type u_1
l : List α✝
b a : α✝
⊢ ∀ (n : ℕ) (h₁ : n < length (set (set l i b) i a)) (h₂ : n < length (set l i a)),
get (set (set l i b) i a) { val := n, isLt := h₁ } = get (set l i a) { val := n, isLt := h₂ } | Please generate a tactic in lean4 to solve the state.
STATE:
case hl
i : ℕ
α✝ : Type u_1
l : List α✝
b a : α✝
⊢ length (set (set l i b) i a) = length (set l i a)
case h
i : ℕ
α✝ : Type u_1
l : List α✝
b a : α✝
⊢ ∀ (n : ℕ) (h₁ : n < length (set (set l i b) i a)) (h₂ : n < length (set l i a)),
get (set (set l i b) i a) { val := n, isLt := h₁ } = get (set l i a) { val := n, isLt := h₂ }
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.set_set | [1842, 1] | [1848, 24] | . intro n _ _
repeat rw [List.get_set]
split <;> simp only | case h
i : ℕ
α✝ : Type u_1
l : List α✝
b a : α✝
⊢ ∀ (n : ℕ) (h₁ : n < length (set (set l i b) i a)) (h₂ : n < length (set l i a)),
get (set (set l i b) i a) { val := n, isLt := h₁ } = get (set l i a) { val := n, isLt := h₂ } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
i : ℕ
α✝ : Type u_1
l : List α✝
b a : α✝
⊢ ∀ (n : ℕ) (h₁ : n < length (set (set l i b) i a)) (h₂ : n < length (set l i a)),
get (set (set l i b) i a) { val := n, isLt := h₁ } = get (set l i a) { val := n, isLt := h₂ }
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.set_set | [1842, 1] | [1848, 24] | rw [List.get_set] | case h
i : ℕ
α✝ : Type u_1
l : List α✝
b a : α✝
n : ℕ
h₁✝ : n < length (set (set l i b) i a)
h₂✝ : n < length (set l i a)
⊢ (if i = n then a else if i = n then b else get l { val := n, isLt := (_ : n < length l) }) =
get (set l i a) { val := n, isLt := h₂✝ } | case h
i : ℕ
α✝ : Type u_1
l : List α✝
b a : α✝
n : ℕ
h₁✝ : n < length (set (set l i b) i a)
h₂✝ : n < length (set l i a)
⊢ (if i = n then a else if i = n then b else get l { val := n, isLt := (_ : n < length l) }) =
if i = n then a else get l { val := n, isLt := (_ : n < length l) } | Please generate a tactic in lean4 to solve the state.
STATE:
case h
i : ℕ
α✝ : Type u_1
l : List α✝
b a : α✝
n : ℕ
h₁✝ : n < length (set (set l i b) i a)
h₂✝ : n < length (set l i a)
⊢ (if i = n then a else if i = n then b else get l { val := n, isLt := (_ : n < length l) }) =
get (set l i a) { val := n, isLt := h₂✝ }
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_eq | [1850, 1] | [1859, 80] | subst h | i j : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h : i = j
⊢ modifyNth f i (modifyNth g j l) = modifyNth (f ∘ g) i l | i : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
⊢ modifyNth f i (modifyNth g i l) = modifyNth (f ∘ g) i l | 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 (f ∘ g) i l
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_eq | [1850, 1] | [1859, 80] | if h₁: i < length l then
rw [List.modifyNth_eq_set_get _ h₁, List.modifyNth_eq_set_get _ h₁, List.modifyNth_eq_set_get,
List.get_set_eq, set_set, Function.comp_apply] <;>
simp only [h₁, length_set]
else
simp only [not_lt] at h₁
have h₃: length l ≤ i := by simp only [modify_get?_length, h₁]
rw [modifyNth_ge_length h₁, modifyNth_ge_length h₃, modifyNth_ge_length h₁] | i : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
⊢ modifyNth f i (modifyNth g i l) = modifyNth (f ∘ g) i l | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
⊢ modifyNth f i (modifyNth g i l) = modifyNth (f ∘ g) i l
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_eq | [1850, 1] | [1859, 80] | rw [List.modifyNth_eq_set_get _ h₁, List.modifyNth_eq_set_get _ h₁, List.modifyNth_eq_set_get,
List.get_set_eq, set_set, Function.comp_apply] <;>
simp only [h₁, length_set] | i : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h₁ : i < length l
⊢ modifyNth f i (modifyNth g i l) = modifyNth (f ∘ g) i l | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h₁ : i < length l
⊢ modifyNth f i (modifyNth g i l) = modifyNth (f ∘ g) i l
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_eq | [1850, 1] | [1859, 80] | simp only [not_lt] at h₁ | i : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h₁ : ¬i < length l
⊢ modifyNth f i (modifyNth g i l) = modifyNth (f ∘ g) i l | i : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h₁ : length l ≤ i
⊢ modifyNth f i (modifyNth g i l) = modifyNth (f ∘ g) i l | Please generate a tactic in lean4 to solve the state.
STATE:
i : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h₁ : ¬i < length l
⊢ modifyNth f i (modifyNth g i l) = modifyNth (f ∘ g) i l
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_eq | [1850, 1] | [1859, 80] | have h₃: length l ≤ i := by simp only [modify_get?_length, h₁] | i : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h₁ : length l ≤ i
⊢ modifyNth f i (modifyNth g i l) = modifyNth (f ∘ g) i l | i : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h₁ : length l ≤ i
h₃ : length l ≤ i
⊢ modifyNth f i (modifyNth g i l) = modifyNth (f ∘ g) i l | Please generate a tactic in lean4 to solve the state.
STATE:
i : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h₁ : length l ≤ i
⊢ modifyNth f i (modifyNth g i l) = modifyNth (f ∘ g) i l
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_eq | [1850, 1] | [1859, 80] | rw [modifyNth_ge_length h₁, modifyNth_ge_length h₃, modifyNth_ge_length h₁] | i : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h₁ : length l ≤ i
h₃ : length l ≤ i
⊢ modifyNth f i (modifyNth g i l) = modifyNth (f ∘ g) i l | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h₁ : length l ≤ i
h₃ : length l ≤ i
⊢ modifyNth f i (modifyNth g i l) = modifyNth (f ∘ g) i l
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_modifyNth_eq | [1850, 1] | [1859, 80] | simp only [modify_get?_length, h₁] | i : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h₁ : length l ≤ i
⊢ length l ≤ i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i : ℕ
α✝ : Type u_1
f g : α✝ → α✝
l : List α✝
h₁ : length l ≤ i
⊢ length l ≤ i
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_comm_of_comm | [1862, 1] | [1870, 75] | cases heq: decide (i = j) with
| true =>
simp only [decide_eq_true_eq] at heq
rw [List.modifyNth_modifyNth_eq heq, List.modifyNth_modifyNth_eq (Eq.symm heq), P.comp_eq, heq]
| false =>
simp only [decide_eq_false_iff_not] at heq
have heq₂ : j ≠ i := by simp only [ne_eq, ne_comm, heq, not_false_iff]
rw [List.modifyNth_modifyNth_ne heq, List.modifyNth_modifyNth_ne heq₂] | α✝ : Type u_1
f g : α✝ → α✝
i j : ℕ
l : List α✝
P : Function.Commute f g
⊢ 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:
α✝ : Type u_1
f g : α✝ → α✝
i j : ℕ
l : List α✝
P : Function.Commute f g
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_comm_of_comm | [1862, 1] | [1870, 75] | simp only [decide_eq_true_eq] at heq | case true
α✝ : Type u_1
f g : α✝ → α✝
i j : ℕ
l : List α✝
P : Function.Commute f g
heq : decide (i = j) = true
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l) | case true
α✝ : Type u_1
f g : α✝ → α✝
i j : ℕ
l : List α✝
P : Function.Commute f g
heq : i = j
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l) | Please generate a tactic in lean4 to solve the state.
STATE:
case true
α✝ : Type u_1
f g : α✝ → α✝
i j : ℕ
l : List α✝
P : Function.Commute f g
heq : decide (i = j) = true
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_comm_of_comm | [1862, 1] | [1870, 75] | rw [List.modifyNth_modifyNth_eq heq, List.modifyNth_modifyNth_eq (Eq.symm heq), P.comp_eq, heq] | case true
α✝ : Type u_1
f g : α✝ → α✝
i j : ℕ
l : List α✝
P : Function.Commute f g
heq : 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:
case true
α✝ : Type u_1
f g : α✝ → α✝
i j : ℕ
l : List α✝
P : Function.Commute f g
heq : i = j
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_comm_of_comm | [1862, 1] | [1870, 75] | simp only [decide_eq_false_iff_not] at heq | case false
α✝ : Type u_1
f g : α✝ → α✝
i j : ℕ
l : List α✝
P : Function.Commute f g
heq : decide (i = j) = false
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l) | case false
α✝ : Type u_1
f g : α✝ → α✝
i j : ℕ
l : List α✝
P : Function.Commute f g
heq : ¬i = j
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l) | Please generate a tactic in lean4 to solve the state.
STATE:
case false
α✝ : Type u_1
f g : α✝ → α✝
i j : ℕ
l : List α✝
P : Function.Commute f g
heq : decide (i = j) = false
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_comm_of_comm | [1862, 1] | [1870, 75] | have heq₂ : j ≠ i := by simp only [ne_eq, ne_comm, heq, not_false_iff] | case false
α✝ : Type u_1
f g : α✝ → α✝
i j : ℕ
l : List α✝
P : Function.Commute f g
heq : ¬i = j
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l) | case false
α✝ : Type u_1
f g : α✝ → α✝
i j : ℕ
l : List α✝
P : Function.Commute f g
heq : ¬i = j
heq₂ : j ≠ i
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l) | Please generate a tactic in lean4 to solve the state.
STATE:
case false
α✝ : Type u_1
f g : α✝ → α✝
i j : ℕ
l : List α✝
P : Function.Commute f g
heq : ¬i = j
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_comm_of_comm | [1862, 1] | [1870, 75] | rw [List.modifyNth_modifyNth_ne heq, List.modifyNth_modifyNth_ne heq₂] | case false
α✝ : Type u_1
f g : α✝ → α✝
i j : ℕ
l : List α✝
P : Function.Commute f g
heq : ¬i = j
heq₂ : j ≠ i
⊢ 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:
case false
α✝ : Type u_1
f g : α✝ → α✝
i j : ℕ
l : List α✝
P : Function.Commute f g
heq : ¬i = j
heq₂ : j ≠ i
⊢ modifyNth f i (modifyNth g j l) = modifyNth g j (modifyNth f i l)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyNth_comm_of_comm | [1862, 1] | [1870, 75] | simp only [ne_eq, ne_comm, heq, not_false_iff] | α✝ : Type u_1
f g : α✝ → α✝
i j : ℕ
l : List α✝
P : Function.Commute f g
heq : ¬i = j
⊢ j ≠ i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
f g : α✝ → α✝
i j : ℕ
l : List α✝
P : Function.Commute f g
heq : ¬i = j
⊢ j ≠ i
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_append | [1872, 1] | [1889, 97] | induction l₁ with
| nil =>
simp only [nil_append, List.append_eq, splitOnP_nil, modifyLast_singleton]
apply List.splitOnP_eq_single
apply h
| cons head tail ih =>
rw [cons_append, splitOnP_cons, splitOnP_cons]
split
case inl heq =>
rw [ih,modifyLast_cons]
apply List.splitOnP_ne_nil
case inr heq =>
rw [ih, modifyLast_eq_modifyNth, modifyLast_eq_modifyNth,
modifyHead_eq_modifyNth, modifyHead_eq_modifyNth,
modifyNth_comm_of_comm]
simp only [List.append_eq, tsub_le_iff_right, ge_iff_le, zero_le, nonpos_iff_eq_zero, modify_get?_length]
simp only [Function.Commute, Function.Semiconj, List.append_eq, cons_append, forall_const] | α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
l₁ : List α✝
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
⊢ splitOnP P (l₁ ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P l₁) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
l₁ : List α✝
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
⊢ splitOnP P (l₁ ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P l₁)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_append | [1872, 1] | [1889, 97] | simp only [nil_append, List.append_eq, splitOnP_nil, modifyLast_singleton] | case nil
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
⊢ splitOnP P ([] ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P []) | case nil
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
⊢ splitOnP P l₂ = [l₂] | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
⊢ splitOnP P ([] ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P [])
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_append | [1872, 1] | [1889, 97] | apply List.splitOnP_eq_single | case nil
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
⊢ splitOnP P l₂ = [l₂] | case nil.h
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
⊢ ∀ (x : α✝), x ∈ l₂ → ¬P x = true | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
⊢ splitOnP P l₂ = [l₂]
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_append | [1872, 1] | [1889, 97] | apply h | case nil.h
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
⊢ ∀ (x : α✝), x ∈ l₂ → ¬P x = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil.h
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
⊢ ∀ (x : α✝), x ∈ l₂ → ¬P x = true
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_append | [1872, 1] | [1889, 97] | rw [cons_append, splitOnP_cons, splitOnP_cons] | case cons
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
⊢ splitOnP P (head :: tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P (head :: tail)) | case cons
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
⊢ (if P head = true then [] :: splitOnP P (tail ++ l₂) else modifyHead (cons head) (splitOnP P (tail ++ l₂))) =
modifyLast (fun x => List.append x l₂)
(if P head = true then [] :: splitOnP P tail else modifyHead (cons head) (splitOnP P tail)) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
⊢ splitOnP P (head :: tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P (head :: tail))
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_append | [1872, 1] | [1889, 97] | split | case cons
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
⊢ (if P head = true then [] :: splitOnP P (tail ++ l₂) else modifyHead (cons head) (splitOnP P (tail ++ l₂))) =
modifyLast (fun x => List.append x l₂)
(if P head = true then [] :: splitOnP P tail else modifyHead (cons head) (splitOnP P tail)) | case cons.inl
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
h✝ : P head = true
⊢ [] :: splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) ([] :: splitOnP P tail)
case cons.inr
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
h✝ : ¬P head = true
⊢ modifyHead (cons head) (splitOnP P (tail ++ l₂)) =
modifyLast (fun x => List.append x l₂) (modifyHead (cons head) (splitOnP P tail)) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
⊢ (if P head = true then [] :: splitOnP P (tail ++ l₂) else modifyHead (cons head) (splitOnP P (tail ++ l₂))) =
modifyLast (fun x => List.append x l₂)
(if P head = true then [] :: splitOnP P tail else modifyHead (cons head) (splitOnP P tail))
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_append | [1872, 1] | [1889, 97] | case inl heq =>
rw [ih,modifyLast_cons]
apply List.splitOnP_ne_nil | α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : P head = true
⊢ [] :: splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) ([] :: splitOnP P tail) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : P head = true
⊢ [] :: splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) ([] :: splitOnP P tail)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_append | [1872, 1] | [1889, 97] | case inr heq =>
rw [ih, modifyLast_eq_modifyNth, modifyLast_eq_modifyNth,
modifyHead_eq_modifyNth, modifyHead_eq_modifyNth,
modifyNth_comm_of_comm]
simp only [List.append_eq, tsub_le_iff_right, ge_iff_le, zero_le, nonpos_iff_eq_zero, modify_get?_length]
simp only [Function.Commute, Function.Semiconj, List.append_eq, cons_append, forall_const] | α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : ¬P head = true
⊢ modifyHead (cons head) (splitOnP P (tail ++ l₂)) =
modifyLast (fun x => List.append x l₂) (modifyHead (cons head) (splitOnP P tail)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : ¬P head = true
⊢ modifyHead (cons head) (splitOnP P (tail ++ l₂)) =
modifyLast (fun x => List.append x l₂) (modifyHead (cons head) (splitOnP P tail))
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_append | [1872, 1] | [1889, 97] | rw [ih,modifyLast_cons] | α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : P head = true
⊢ [] :: splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) ([] :: splitOnP P tail) | α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : P head = true
⊢ splitOnP P tail ≠ [] | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : P head = true
⊢ [] :: splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) ([] :: splitOnP P tail)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_append | [1872, 1] | [1889, 97] | apply List.splitOnP_ne_nil | α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : P head = true
⊢ splitOnP P tail ≠ [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : P head = true
⊢ splitOnP P tail ≠ []
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_append | [1872, 1] | [1889, 97] | rw [ih, modifyLast_eq_modifyNth, modifyLast_eq_modifyNth,
modifyHead_eq_modifyNth, modifyHead_eq_modifyNth,
modifyNth_comm_of_comm] | α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : ¬P head = true
⊢ modifyHead (cons head) (splitOnP P (tail ++ l₂)) =
modifyLast (fun x => List.append x l₂) (modifyHead (cons head) (splitOnP P tail)) | α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : ¬P head = true
⊢ modifyNth (fun x => List.append x l₂) (length (splitOnP P tail) - 1) (modifyNth (cons head) 0 (splitOnP P tail)) =
modifyNth (fun x => List.append x l₂) (length (modifyNth (cons head) 0 (splitOnP P tail)) - 1)
(modifyNth (cons head) 0 (splitOnP P tail))
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : ¬P head = true
⊢ Function.Commute (cons head) fun x => List.append x l₂ | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : ¬P head = true
⊢ modifyHead (cons head) (splitOnP P (tail ++ l₂)) =
modifyLast (fun x => List.append x l₂) (modifyHead (cons head) (splitOnP P tail))
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_append | [1872, 1] | [1889, 97] | simp only [List.append_eq, tsub_le_iff_right, ge_iff_le, zero_le, nonpos_iff_eq_zero, modify_get?_length] | α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : ¬P head = true
⊢ modifyNth (fun x => List.append x l₂) (length (splitOnP P tail) - 1) (modifyNth (cons head) 0 (splitOnP P tail)) =
modifyNth (fun x => List.append x l₂) (length (modifyNth (cons head) 0 (splitOnP P tail)) - 1)
(modifyNth (cons head) 0 (splitOnP P tail))
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : ¬P head = true
⊢ Function.Commute (cons head) fun x => List.append x l₂ | α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : ¬P head = true
⊢ Function.Commute (cons head) fun x => List.append x l₂ | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : ¬P head = true
⊢ modifyNth (fun x => List.append x l₂) (length (splitOnP P tail) - 1) (modifyNth (cons head) 0 (splitOnP P tail)) =
modifyNth (fun x => List.append x l₂) (length (modifyNth (cons head) 0 (splitOnP P tail)) - 1)
(modifyNth (cons head) 0 (splitOnP P tail))
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : ¬P head = true
⊢ Function.Commute (cons head) fun x => List.append x l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_append | [1872, 1] | [1889, 97] | simp only [Function.Commute, Function.Semiconj, List.append_eq, cons_append, forall_const] | α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : ¬P head = true
⊢ Function.Commute (cons head) fun x => List.append x l₂ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
l₂ : List α✝
P : α✝ → Bool
h : ∀ (e : α✝), e ∈ l₂ → ¬P e = true
head : α✝
tail : List α✝
ih : splitOnP P (tail ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP P tail)
heq : ¬P head = true
⊢ Function.Commute (cons head) fun x => List.append x l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOn_append | [1891, 1] | [1895, 16] | unfold splitOn | α : Type u_1
delim : α
inst✝ : BEq α
l₁ l₂ : List α
h : ∀ (e : α), e ∈ l₂ → ¬(e == delim) = true
⊢ splitOn delim (l₁ ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOn delim l₁) | α : Type u_1
delim : α
inst✝ : BEq α
l₁ l₂ : List α
h : ∀ (e : α), e ∈ l₂ → ¬(e == delim) = true
⊢ splitOnP (fun x => x == delim) (l₁ ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP (fun x => x == delim) l₁) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : α
inst✝ : BEq α
l₁ l₂ : List α
h : ∀ (e : α), e ∈ l₂ → ¬(e == delim) = true
⊢ splitOn delim (l₁ ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOn delim l₁)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOn_append | [1891, 1] | [1895, 16] | rw [List.splitOnP_append] | α : Type u_1
delim : α
inst✝ : BEq α
l₁ l₂ : List α
h : ∀ (e : α), e ∈ l₂ → ¬(e == delim) = true
⊢ splitOnP (fun x => x == delim) (l₁ ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP (fun x => x == delim) l₁) | α : Type u_1
delim : α
inst✝ : BEq α
l₁ l₂ : List α
h : ∀ (e : α), e ∈ l₂ → ¬(e == delim) = true
⊢ ∀ (e : α), e ∈ l₂ → ¬(e == delim) = true | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : α
inst✝ : BEq α
l₁ l₂ : List α
h : ∀ (e : α), e ∈ l₂ → ¬(e == delim) = true
⊢ splitOnP (fun x => x == delim) (l₁ ++ l₂) = modifyLast (fun x => List.append x l₂) (splitOnP (fun x => x == delim) l₁)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOn_append | [1891, 1] | [1895, 16] | intro e ein | α : Type u_1
delim : α
inst✝ : BEq α
l₁ l₂ : List α
h : ∀ (e : α), e ∈ l₂ → ¬(e == delim) = true
⊢ ∀ (e : α), e ∈ l₂ → ¬(e == delim) = true | α : Type u_1
delim : α
inst✝ : BEq α
l₁ l₂ : List α
h : ∀ (e : α), e ∈ l₂ → ¬(e == delim) = true
e : α
ein : e ∈ l₂
⊢ ¬(e == delim) = true | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : α
inst✝ : BEq α
l₁ l₂ : List α
h : ∀ (e : α), e ∈ l₂ → ¬(e == delim) = true
⊢ ∀ (e : α), e ∈ l₂ → ¬(e == delim) = true
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOn_append | [1891, 1] | [1895, 16] | exact h e ein | α : Type u_1
delim : α
inst✝ : BEq α
l₁ l₂ : List α
h : ∀ (e : α), e ∈ l₂ → ¬(e == delim) = true
e : α
ein : e ∈ l₂
⊢ ¬(e == delim) = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
delim : α
inst✝ : BEq α
l₁ l₂ : List α
h : ∀ (e : α), e ∈ l₂ → ¬(e == delim) = true
e : α
ein : e ∈ l₂
⊢ ¬(e == delim) = true
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyHead_append | [1897, 1] | [1900, 58] | cases l₁ with
| nil => simp only [ne_eq, not_true] at h
| cons head tail => simp only [modifyHead, cons_append] | α✝ : Type u_1
l₁ : List α✝
f : α✝ → α✝
l₂ : List α✝
h : l₁ ≠ []
⊢ modifyHead f (l₁ ++ l₂) = modifyHead f l₁ ++ l₂ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
l₁ : List α✝
f : α✝ → α✝
l₂ : List α✝
h : l₁ ≠ []
⊢ modifyHead f (l₁ ++ l₂) = modifyHead f l₁ ++ l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyHead_append | [1897, 1] | [1900, 58] | simp only [ne_eq, not_true] at h | case nil
α✝ : Type u_1
f : α✝ → α✝
l₂ : List α✝
h : [] ≠ []
⊢ modifyHead f ([] ++ l₂) = modifyHead f [] ++ l₂ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α✝ : Type u_1
f : α✝ → α✝
l₂ : List α✝
h : [] ≠ []
⊢ modifyHead f ([] ++ l₂) = modifyHead f [] ++ l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.modifyHead_append | [1897, 1] | [1900, 58] | simp only [modifyHead, cons_append] | case cons
α✝ : Type u_1
f : α✝ → α✝
l₂ : List α✝
head : α✝
tail : List α✝
h : head :: tail ≠ []
⊢ modifyHead f (head :: tail ++ l₂) = modifyHead f (head :: tail) ++ l₂ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α✝ : Type u_1
f : α✝ → α✝
l₂ : List α✝
head : α✝
tail : List α✝
h : head :: tail ≠ []
⊢ modifyHead f (head :: tail ++ l₂) = modifyHead f (head :: tail) ++ l₂
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_last | [1902, 1] | [1914, 33] | induction front with
| nil =>
simp only [nil_append, splitOnP_cons, hsep, modifyHead, ite_true, splitOnP_nil, singleton_append, cons.injEq,
true_and]
rw [List.splitOnP_eq_single]
apply h
| cons hd tl ih =>
simp only [cons_append, splitOnP_cons]
split
. simp only [ih, cons_append]
. rw [ih, List.modifyHead_append]
apply List.splitOnP_ne_nil | α : Type u_1
P : α → Bool
inst✝ : BEq α
front : List α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
⊢ splitOnP P (front ++ sep :: tail) = splitOnP P front ++ [tail] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
P : α → Bool
inst✝ : BEq α
front : List α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
⊢ splitOnP P (front ++ sep :: tail) = splitOnP P front ++ [tail]
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_last | [1902, 1] | [1914, 33] | simp only [nil_append, splitOnP_cons, hsep, modifyHead, ite_true, splitOnP_nil, singleton_append, cons.injEq,
true_and] | case nil
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
⊢ splitOnP P ([] ++ sep :: tail) = splitOnP P [] ++ [tail] | case nil
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
⊢ splitOnP P tail = [tail] | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
⊢ splitOnP P ([] ++ sep :: tail) = splitOnP P [] ++ [tail]
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_last | [1902, 1] | [1914, 33] | rw [List.splitOnP_eq_single] | case nil
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
⊢ splitOnP P tail = [tail] | case nil.h
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
⊢ ∀ (x : α), x ∈ tail → ¬P x = true | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
⊢ splitOnP P tail = [tail]
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_last | [1902, 1] | [1914, 33] | apply h | case nil.h
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
⊢ ∀ (x : α), x ∈ tail → ¬P x = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil.h
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
⊢ ∀ (x : α), x ∈ tail → ¬P x = true
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_last | [1902, 1] | [1914, 33] | simp only [cons_append, splitOnP_cons] | case cons
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
hd : α
tl : List α
ih : splitOnP P (tl ++ sep :: tail) = splitOnP P tl ++ [tail]
⊢ splitOnP P (hd :: tl ++ sep :: tail) = splitOnP P (hd :: tl) ++ [tail] | case cons
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
hd : α
tl : List α
ih : splitOnP P (tl ++ sep :: tail) = splitOnP P tl ++ [tail]
⊢ (if P hd = true then [] :: splitOnP P (tl ++ sep :: tail)
else modifyHead (cons hd) (splitOnP P (tl ++ sep :: tail))) =
(if P hd = true then [] :: splitOnP P tl else modifyHead (cons hd) (splitOnP P tl)) ++ [tail] | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
hd : α
tl : List α
ih : splitOnP P (tl ++ sep :: tail) = splitOnP P tl ++ [tail]
⊢ splitOnP P (hd :: tl ++ sep :: tail) = splitOnP P (hd :: tl) ++ [tail]
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_last | [1902, 1] | [1914, 33] | split | case cons
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
hd : α
tl : List α
ih : splitOnP P (tl ++ sep :: tail) = splitOnP P tl ++ [tail]
⊢ (if P hd = true then [] :: splitOnP P (tl ++ sep :: tail)
else modifyHead (cons hd) (splitOnP P (tl ++ sep :: tail))) =
(if P hd = true then [] :: splitOnP P tl else modifyHead (cons hd) (splitOnP P tl)) ++ [tail] | case cons.inl
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
hd : α
tl : List α
ih : splitOnP P (tl ++ sep :: tail) = splitOnP P tl ++ [tail]
h✝ : P hd = true
⊢ [] :: splitOnP P (tl ++ sep :: tail) = [] :: splitOnP P tl ++ [tail]
case cons.inr
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
hd : α
tl : List α
ih : splitOnP P (tl ++ sep :: tail) = splitOnP P tl ++ [tail]
h✝ : ¬P hd = true
⊢ modifyHead (cons hd) (splitOnP P (tl ++ sep :: tail)) = modifyHead (cons hd) (splitOnP P tl) ++ [tail] | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
hd : α
tl : List α
ih : splitOnP P (tl ++ sep :: tail) = splitOnP P tl ++ [tail]
⊢ (if P hd = true then [] :: splitOnP P (tl ++ sep :: tail)
else modifyHead (cons hd) (splitOnP P (tl ++ sep :: tail))) =
(if P hd = true then [] :: splitOnP P tl else modifyHead (cons hd) (splitOnP P tl)) ++ [tail]
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_last | [1902, 1] | [1914, 33] | . simp only [ih, cons_append] | case cons.inl
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
hd : α
tl : List α
ih : splitOnP P (tl ++ sep :: tail) = splitOnP P tl ++ [tail]
h✝ : P hd = true
⊢ [] :: splitOnP P (tl ++ sep :: tail) = [] :: splitOnP P tl ++ [tail]
case cons.inr
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
hd : α
tl : List α
ih : splitOnP P (tl ++ sep :: tail) = splitOnP P tl ++ [tail]
h✝ : ¬P hd = true
⊢ modifyHead (cons hd) (splitOnP P (tl ++ sep :: tail)) = modifyHead (cons hd) (splitOnP P tl) ++ [tail] | case cons.inr
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
hd : α
tl : List α
ih : splitOnP P (tl ++ sep :: tail) = splitOnP P tl ++ [tail]
h✝ : ¬P hd = true
⊢ modifyHead (cons hd) (splitOnP P (tl ++ sep :: tail)) = modifyHead (cons hd) (splitOnP P tl) ++ [tail] | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.inl
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
hd : α
tl : List α
ih : splitOnP P (tl ++ sep :: tail) = splitOnP P tl ++ [tail]
h✝ : P hd = true
⊢ [] :: splitOnP P (tl ++ sep :: tail) = [] :: splitOnP P tl ++ [tail]
case cons.inr
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
hd : α
tl : List α
ih : splitOnP P (tl ++ sep :: tail) = splitOnP P tl ++ [tail]
h✝ : ¬P hd = true
⊢ modifyHead (cons hd) (splitOnP P (tl ++ sep :: tail)) = modifyHead (cons hd) (splitOnP P tl) ++ [tail]
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOnP_last | [1902, 1] | [1914, 33] | . rw [ih, List.modifyHead_append]
apply List.splitOnP_ne_nil | case cons.inr
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
hd : α
tl : List α
ih : splitOnP P (tl ++ sep :: tail) = splitOnP P tl ++ [tail]
h✝ : ¬P hd = true
⊢ modifyHead (cons hd) (splitOnP P (tl ++ sep :: tail)) = modifyHead (cons hd) (splitOnP P tl) ++ [tail] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.inr
α : Type u_1
P : α → Bool
inst✝ : BEq α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬P e = true
hsep : P sep = true
hd : α
tl : List α
ih : splitOnP P (tl ++ sep :: tail) = splitOnP P tl ++ [tail]
h✝ : ¬P hd = true
⊢ modifyHead (cons hd) (splitOnP P (tl ++ sep :: tail)) = modifyHead (cons hd) (splitOnP P tl) ++ [tail]
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOn_last | [1916, 1] | [1920, 33] | unfold splitOn | α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
front : List α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬(e == sep) = true
⊢ splitOn sep (front ++ sep :: tail) = splitOn sep front ++ [tail] | α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
front : List α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬(e == sep) = true
⊢ splitOnP (fun x => x == sep) (front ++ sep :: tail) = splitOnP (fun x => x == sep) front ++ [tail] | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
front : List α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬(e == sep) = true
⊢ splitOn sep (front ++ sep :: tail) = splitOn sep front ++ [tail]
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOn_last | [1916, 1] | [1920, 33] | apply List.splitOnP_last | α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
front : List α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬(e == sep) = true
⊢ splitOnP (fun x => x == sep) (front ++ sep :: tail) = splitOnP (fun x => x == sep) front ++ [tail] | case h
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
front : List α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬(e == sep) = true
⊢ ∀ (e : α), e ∈ tail → ¬(e == sep) = true
case hsep
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
front : List α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬(e == sep) = true
⊢ (sep == sep) = true | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
front : List α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬(e == sep) = true
⊢ splitOnP (fun x => x == sep) (front ++ sep :: tail) = splitOnP (fun x => x == sep) front ++ [tail]
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOn_last | [1916, 1] | [1920, 33] | . exact h | case h
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
front : List α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬(e == sep) = true
⊢ ∀ (e : α), e ∈ tail → ¬(e == sep) = true
case hsep
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
front : List α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬(e == sep) = true
⊢ (sep == sep) = true | case hsep
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
front : List α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬(e == sep) = true
⊢ (sep == sep) = true | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
front : List α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬(e == sep) = true
⊢ ∀ (e : α), e ∈ tail → ¬(e == sep) = true
case hsep
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
front : List α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬(e == sep) = true
⊢ (sep == sep) = true
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.splitOn_last | [1916, 1] | [1920, 33] | . simp only [beq_self_eq_true] | case hsep
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
front : List α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬(e == sep) = true
⊢ (sep == sep) = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hsep
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
front : List α
sep : α
tail : List α
h : ∀ (e : α), e ∈ tail → ¬(e == sep) = true
⊢ (sep == sep) = true
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | WithTop.untop'_min_left | [1922, 1] | [1926, 67] | cases y with
| none => simp only [none_eq_top, ge_iff_le, le_top, min_eq_left, untop'_coe, untop'_top, min_self]
| some y' => rw [some_eq_coe, ← coe_min, untop'_coe, untop'_coe] | α : Type u_1
d : α
inst✝ : LinearOrder α
x : α
y : WithTop α
⊢ untop' d (min (↑x) y) = min x (untop' x y) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
d : α
inst✝ : LinearOrder α
x : α
y : WithTop α
⊢ untop' d (min (↑x) y) = min x (untop' x y)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | WithTop.untop'_min_left | [1922, 1] | [1926, 67] | simp only [none_eq_top, ge_iff_le, le_top, min_eq_left, untop'_coe, untop'_top, min_self] | case none
α : Type u_1
d : α
inst✝ : LinearOrder α
x : α
⊢ untop' d (min (↑x) none) = min x (untop' x none) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case none
α : Type u_1
d : α
inst✝ : LinearOrder α
x : α
⊢ untop' d (min (↑x) none) = min x (untop' x none)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | WithTop.untop'_min_left | [1922, 1] | [1926, 67] | rw [some_eq_coe, ← coe_min, untop'_coe, untop'_coe] | case some
α : Type u_1
d : α
inst✝ : LinearOrder α
x y' : α
⊢ untop' d (min (↑x) (Option.some y')) = min x (untop' x (Option.some y')) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case some
α : Type u_1
d : α
inst✝ : LinearOrder α
x y' : α
⊢ untop' d (min (↑x) (Option.some y')) = min x (untop' x (Option.some y'))
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | WithTop.untop'_min_right | [1928, 1] | [1931, 24] | rw [min_comm x, min_comm _ y] | α : Type u_1
d : α
inst✝ : LinearOrder α
x : WithTop α
y : α
⊢ untop' d (min x ↑y) = min (untop' y x) y | α : Type u_1
d : α
inst✝ : LinearOrder α
x : WithTop α
y : α
⊢ untop' d (min (↑y) x) = min y (untop' y x) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
d : α
inst✝ : LinearOrder α
x : WithTop α
y : α
⊢ untop' d (min x ↑y) = min (untop' y x) y
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | WithTop.untop'_min_right | [1928, 1] | [1931, 24] | apply untop'_min_left | α : Type u_1
d : α
inst✝ : LinearOrder α
x : WithTop α
y : α
⊢ untop' d (min (↑y) x) = min y (untop' y x) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
d : α
inst✝ : LinearOrder α
x : WithTop α
y : α
⊢ untop' d (min (↑y) x) = min y (untop' y x)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | match hl: l₂ with
| [] => simp only [ne_eq, not_true] at hne_nil
| [elem] =>
intro ⟨s,t, heq⟩
simp [List.intercalate] at heq
apply h elem (List.mem_singleton_self elem)
simp [← heq]
exists s, t
simp only [append_assoc]
| head::mid::tail =>
intro contr
simp [intercalate, intersperse_cons_cons] at contr
cases isInfix_split contr (length (delim ++ head ++ delim)) with
| inl hinf=>
rw [← append_assoc, ← append_assoc, take_left] at hinf
apply h head ?_ hinf
simp only [mem_cons, true_or]
| inr hinf =>
rw [length_append, length_append, add_assoc, add_assoc,
← append_assoc,← append_assoc, ← intercalate, drop_append_eq_append_drop,
drop_append_eq_append_drop, drop_length_le, length_append, Nat.sub_sub,
Nat.add_comm (length l₁), ← Nat.add_assoc, ←Nat.sub_sub, Nat.add_sub_self_left,
Nat.sub_sub, Nat.add_comm (length l₁),← Nat.sub_sub, length_append,length_append,
← Nat.sub_sub, ← Nat.sub_sub, Nat.add_assoc, Nat.add_sub_self_left, Nat.add_sub_self_left,
Nat.add_sub_self_left] at hinf
have not_inf := h head (by simp only [mem_cons, true_or])
have hge: 1 ≤ length l₁ := by
apply Nat.succ_le_of_lt ( length_pos_of_ne_nil _)
intro x; simp [x] at not_inf
simp only [Nat.sub_eq_zero_of_le hge, tsub_le_iff_right, ge_iff_le, nil_append, drop] at hinf
have tail_notin :∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim := by
intro e ein
apply h
rw [mem_cons]; right; exact ein
apply not_isInfix_intercalate_by_element l₁ delim (mid::tail) tail_notin _
. simp only [ne_eq, not_false_iff]
. apply isInfix_trans hinf
exists take (length delim + 1 - length l₁) delim, []
rw [← append_assoc, take_append_drop, append_nil, append_assoc]
. exact hlen
. simp [length_append, tsub_le_iff_right, ge_iff_le]
apply Nat.le_sub_of_add_le
rw [add_assoc]
apply Nat.add_le_add_left
apply Nat.add_le_add_left
rw [add_comm]
exact hlen | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
h : ∀ (e : List α), e ∈ l₂ → ¬l₁ <:+: delim ++ e ++ delim
hlen : length l₁ ≤ 1 + length delim
hne_nil : l₂ ≠ []
⊢ ¬l₁ <:+: delim ++ intercalate delim l₂ ++ delim | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
h : ∀ (e : List α), e ∈ l₂ → ¬l₁ <:+: delim ++ e ++ delim
hlen : length l₁ ≤ 1 + length delim
hne_nil : l₂ ≠ []
⊢ ¬l₁ <:+: delim ++ intercalate delim l₂ ++ delim
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | simp only [ne_eq, not_true] at hne_nil | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
h : ∀ (e : List α), e ∈ [] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [] ≠ []
hl : l₂ = []
⊢ ¬l₁ <:+: delim ++ intercalate delim [] ++ delim | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
h : ∀ (e : List α), e ∈ [] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [] ≠ []
hl : l₂ = []
⊢ ¬l₁ <:+: delim ++ intercalate delim [] ++ delim
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | intro ⟨s,t, heq⟩ | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
elem : List α
h : ∀ (e : List α), e ∈ [elem] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [elem] ≠ []
hl : l₂ = [elem]
⊢ ¬l₁ <:+: delim ++ intercalate delim [elem] ++ delim | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
elem : List α
h : ∀ (e : List α), e ∈ [elem] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [elem] ≠ []
hl : l₂ = [elem]
s t : List α
heq : s ++ l₁ ++ t = delim ++ intercalate delim [elem] ++ delim
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
elem : List α
h : ∀ (e : List α), e ∈ [elem] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [elem] ≠ []
hl : l₂ = [elem]
⊢ ¬l₁ <:+: delim ++ intercalate delim [elem] ++ delim
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | simp [List.intercalate] at heq | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
elem : List α
h : ∀ (e : List α), e ∈ [elem] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [elem] ≠ []
hl : l₂ = [elem]
s t : List α
heq : s ++ l₁ ++ t = delim ++ intercalate delim [elem] ++ delim
⊢ False | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
elem : List α
h : ∀ (e : List α), e ∈ [elem] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [elem] ≠ []
hl : l₂ = [elem]
s t : List α
heq : s ++ (l₁ ++ t) = delim ++ (elem ++ delim)
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
elem : List α
h : ∀ (e : List α), e ∈ [elem] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [elem] ≠ []
hl : l₂ = [elem]
s t : List α
heq : s ++ l₁ ++ t = delim ++ intercalate delim [elem] ++ delim
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | apply h elem (List.mem_singleton_self elem) | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
elem : List α
h : ∀ (e : List α), e ∈ [elem] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [elem] ≠ []
hl : l₂ = [elem]
s t : List α
heq : s ++ (l₁ ++ t) = delim ++ (elem ++ delim)
⊢ False | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
elem : List α
h : ∀ (e : List α), e ∈ [elem] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [elem] ≠ []
hl : l₂ = [elem]
s t : List α
heq : s ++ (l₁ ++ t) = delim ++ (elem ++ delim)
⊢ l₁ <:+: delim ++ elem ++ delim | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
elem : List α
h : ∀ (e : List α), e ∈ [elem] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [elem] ≠ []
hl : l₂ = [elem]
s t : List α
heq : s ++ (l₁ ++ t) = delim ++ (elem ++ delim)
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | simp [← heq] | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
elem : List α
h : ∀ (e : List α), e ∈ [elem] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [elem] ≠ []
hl : l₂ = [elem]
s t : List α
heq : s ++ (l₁ ++ t) = delim ++ (elem ++ delim)
⊢ l₁ <:+: delim ++ elem ++ delim | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
elem : List α
h : ∀ (e : List α), e ∈ [elem] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [elem] ≠ []
hl : l₂ = [elem]
s t : List α
heq : s ++ (l₁ ++ t) = delim ++ (elem ++ delim)
⊢ l₁ <:+: s ++ (l₁ ++ t) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
elem : List α
h : ∀ (e : List α), e ∈ [elem] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [elem] ≠ []
hl : l₂ = [elem]
s t : List α
heq : s ++ (l₁ ++ t) = delim ++ (elem ++ delim)
⊢ l₁ <:+: delim ++ elem ++ delim
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | exists s, t | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
elem : List α
h : ∀ (e : List α), e ∈ [elem] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [elem] ≠ []
hl : l₂ = [elem]
s t : List α
heq : s ++ (l₁ ++ t) = delim ++ (elem ++ delim)
⊢ l₁ <:+: s ++ (l₁ ++ t) | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
elem : List α
h : ∀ (e : List α), e ∈ [elem] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [elem] ≠ []
hl : l₂ = [elem]
s t : List α
heq : s ++ (l₁ ++ t) = delim ++ (elem ++ delim)
⊢ s ++ l₁ ++ t = s ++ (l₁ ++ t) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
elem : List α
h : ∀ (e : List α), e ∈ [elem] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [elem] ≠ []
hl : l₂ = [elem]
s t : List α
heq : s ++ (l₁ ++ t) = delim ++ (elem ++ delim)
⊢ l₁ <:+: s ++ (l₁ ++ t)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | simp only [append_assoc] | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
elem : List α
h : ∀ (e : List α), e ∈ [elem] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [elem] ≠ []
hl : l₂ = [elem]
s t : List α
heq : s ++ (l₁ ++ t) = delim ++ (elem ++ delim)
⊢ s ++ l₁ ++ t = s ++ (l₁ ++ t) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
elem : List α
h : ∀ (e : List α), e ∈ [elem] → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : [elem] ≠ []
hl : l₂ = [elem]
s t : List α
heq : s ++ (l₁ ++ t) = delim ++ (elem ++ delim)
⊢ s ++ l₁ ++ t = s ++ (l₁ ++ t)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | intro contr | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
⊢ ¬l₁ <:+: delim ++ intercalate delim (head :: mid :: tail) ++ delim | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ intercalate delim (head :: mid :: tail) ++ delim
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
⊢ ¬l₁ <:+: delim ++ intercalate delim (head :: mid :: tail) ++ delim
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | simp [intercalate, intersperse_cons_cons] at contr | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ intercalate delim (head :: mid :: tail) ++ delim
⊢ False | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ intercalate delim (head :: mid :: tail) ++ delim
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | cases isInfix_split contr (length (delim ++ head ++ delim)) with
| inl hinf=>
rw [← append_assoc, ← append_assoc, take_left] at hinf
apply h head ?_ hinf
simp only [mem_cons, true_or]
| inr hinf =>
rw [length_append, length_append, add_assoc, add_assoc,
← append_assoc,← append_assoc, ← intercalate, drop_append_eq_append_drop,
drop_append_eq_append_drop, drop_length_le, length_append, Nat.sub_sub,
Nat.add_comm (length l₁), ← Nat.add_assoc, ←Nat.sub_sub, Nat.add_sub_self_left,
Nat.sub_sub, Nat.add_comm (length l₁),← Nat.sub_sub, length_append,length_append,
← Nat.sub_sub, ← Nat.sub_sub, Nat.add_assoc, Nat.add_sub_self_left, Nat.add_sub_self_left,
Nat.add_sub_self_left] at hinf
have not_inf := h head (by simp only [mem_cons, true_or])
have hge: 1 ≤ length l₁ := by
apply Nat.succ_le_of_lt ( length_pos_of_ne_nil _)
intro x; simp [x] at not_inf
simp only [Nat.sub_eq_zero_of_le hge, tsub_le_iff_right, ge_iff_le, nil_append, drop] at hinf
have tail_notin :∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim := by
intro e ein
apply h
rw [mem_cons]; right; exact ein
apply not_isInfix_intercalate_by_element l₁ delim (mid::tail) tail_notin _
. simp only [ne_eq, not_false_iff]
. apply isInfix_trans hinf
exists take (length delim + 1 - length l₁) delim, []
rw [← append_assoc, take_append_drop, append_nil, append_assoc]
. exact hlen
. simp [length_append, tsub_le_iff_right, ge_iff_le]
apply Nat.le_sub_of_add_le
rw [add_assoc]
apply Nat.add_le_add_left
apply Nat.add_le_add_left
rw [add_comm]
exact hlen | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | rw [← append_assoc, ← append_assoc, take_left] at hinf | case inl
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
take (length (delim ++ head ++ delim))
(delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim))))
⊢ False | case inl
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf : l₁ <:+: delim ++ head ++ delim
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
take (length (delim ++ head ++ delim))
(delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim))))
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | apply h head ?_ hinf | case inl
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf : l₁ <:+: delim ++ head ++ delim
⊢ False | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf : l₁ <:+: delim ++ head ++ delim
⊢ head ∈ head :: mid :: tail | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf : l₁ <:+: delim ++ head ++ delim
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | simp only [mem_cons, true_or] | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf : l₁ <:+: delim ++ head ++ delim
⊢ head ∈ head :: mid :: tail | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf : l₁ <:+: delim ++ head ++ delim
⊢ head ∈ head :: mid :: tail
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | rw [length_append, length_append, add_assoc, add_assoc,
← append_assoc,← append_assoc, ← intercalate, drop_append_eq_append_drop,
drop_append_eq_append_drop, drop_length_le, length_append, Nat.sub_sub,
Nat.add_comm (length l₁), ← Nat.add_assoc, ←Nat.sub_sub, Nat.add_sub_self_left,
Nat.sub_sub, Nat.add_comm (length l₁),← Nat.sub_sub, length_append,length_append,
← Nat.sub_sub, ← Nat.sub_sub, Nat.add_assoc, Nat.add_sub_self_left, Nat.add_sub_self_left,
Nat.add_sub_self_left] at hinf | case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length (delim ++ head ++ delim) + 1 - length l₁)
(delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim))))
⊢ False | case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
⊢ False
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length (delim ++ head ++ delim) + 1 - length l₁)
(delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim))))
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | have not_inf := h head (by simp only [mem_cons, true_or]) | case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
⊢ False
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
not_inf : ¬l₁ <:+: delim ++ head ++ delim
⊢ False
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
⊢ False
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | have hge: 1 ≤ length l₁ := by
apply Nat.succ_le_of_lt ( length_pos_of_ne_nil _)
intro x; simp [x] at not_inf | case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
not_inf : ¬l₁ <:+: delim ++ head ++ delim
⊢ False
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
⊢ False
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
not_inf : ¬l₁ <:+: delim ++ head ++ delim
⊢ False
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | simp only [Nat.sub_eq_zero_of_le hge, tsub_le_iff_right, ge_iff_le, nil_append, drop] at hinf | case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
⊢ False
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
⊢ False
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
⊢ False
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | have tail_notin :∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim := by
intro e ein
apply h
rw [mem_cons]; right; exact ein | case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
⊢ False
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ False
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
⊢ False
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | apply not_isInfix_intercalate_by_element l₁ delim (mid::tail) tail_notin _ | case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ False
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | case inr.hne_nil
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ mid :: tail ≠ []
case inr.a
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ l₁ <:+: delim ++ intercalate delim (mid :: tail) ++ delim
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ length l₁ ≤ 1 + length delim
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ False
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | . simp only [ne_eq, not_false_iff] | case inr.hne_nil
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ mid :: tail ≠ []
case inr.a
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ l₁ <:+: delim ++ intercalate delim (mid :: tail) ++ delim
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ length l₁ ≤ 1 + length delim
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | case inr.a
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ l₁ <:+: delim ++ intercalate delim (mid :: tail) ++ delim
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ length l₁ ≤ 1 + length delim
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.hne_nil
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ mid :: tail ≠ []
case inr.a
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ l₁ <:+: delim ++ intercalate delim (mid :: tail) ++ delim
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ length l₁ ≤ 1 + length delim
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | . apply isInfix_trans hinf
exists take (length delim + 1 - length l₁) delim, []
rw [← append_assoc, take_append_drop, append_nil, append_assoc] | case inr.a
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ l₁ <:+: delim ++ intercalate delim (mid :: tail) ++ delim
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ length l₁ ≤ 1 + length delim
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ length l₁ ≤ 1 + length delim
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.a
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ l₁ <:+: delim ++ intercalate delim (mid :: tail) ++ delim
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ length l₁ ≤ 1 + length delim
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | . exact hlen | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ length l₁ ≤ 1 + length delim
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
tail_notin : ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
⊢ length l₁ ≤ 1 + length delim
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | . simp [length_append, tsub_le_iff_right, ge_iff_le]
apply Nat.le_sub_of_add_le
rw [add_assoc]
apply Nat.add_le_add_left
apply Nat.add_le_add_left
rw [add_comm]
exact hlen | case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
drop (length delim + (length head + (length delim + 1)) - length l₁) (delim ++ head) ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head)) delim ++
drop (length delim + (length head + (length delim + 1)) - length l₁ - length (delim ++ head ++ delim))
(intercalate delim (mid :: tail) ++ delim)
⊢ length (delim ++ head) ≤ length delim + (length head + (length delim + 1)) - length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | simp only [mem_cons, true_or] | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
⊢ head ∈ head :: mid :: tail | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
⊢ head ∈ head :: mid :: tail
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | apply Nat.succ_le_of_lt ( length_pos_of_ne_nil _) | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
not_inf : ¬l₁ <:+: delim ++ head ++ delim
⊢ 1 ≤ length l₁ | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
not_inf : ¬l₁ <:+: delim ++ head ++ delim
⊢ l₁ ≠ [] | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
not_inf : ¬l₁ <:+: delim ++ head ++ delim
⊢ 1 ≤ length l₁
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | intro x | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
not_inf : ¬l₁ <:+: delim ++ head ++ delim
⊢ l₁ ≠ [] | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
not_inf : ¬l₁ <:+: delim ++ head ++ delim
x : l₁ = []
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
not_inf : ¬l₁ <:+: delim ++ head ++ delim
⊢ l₁ ≠ []
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | simp [x] at not_inf | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
not_inf : ¬l₁ <:+: delim ++ head ++ delim
x : l₁ = []
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
hinf :
l₁ <:+:
[] ++ drop (length delim + 1 - length l₁) delim ++ drop (1 - length l₁) (intercalate delim (mid :: tail) ++ delim)
not_inf : ¬l₁ <:+: delim ++ head ++ delim
x : l₁ = []
⊢ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | intro e ein | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
⊢ ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
e : List α
ein : e ∈ mid :: tail
⊢ ¬l₁ <:+: delim ++ e ++ delim | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
⊢ ∀ (e : List α), e ∈ mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | apply h | α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
e : List α
ein : e ∈ mid :: tail
⊢ ¬l₁ <:+: delim ++ e ++ delim | case a
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
e : List α
ein : e ∈ mid :: tail
⊢ e ∈ head :: mid :: tail | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
e : List α
ein : e ∈ mid :: tail
⊢ ¬l₁ <:+: delim ++ e ++ delim
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | rw [mem_cons] | case a
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
e : List α
ein : e ∈ mid :: tail
⊢ e ∈ head :: mid :: tail | case a
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
e : List α
ein : e ∈ mid :: tail
⊢ e = head ∨ e ∈ mid :: tail | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
e : List α
ein : e ∈ mid :: tail
⊢ e ∈ head :: mid :: tail
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.not_isInfix_intercalate_by_element | [1933, 1] | [1986, 19] | right | case a
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
e : List α
ein : e ∈ mid :: tail
⊢ e = head ∨ e ∈ mid :: tail | case a.h
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
e : List α
ein : e ∈ mid :: tail
⊢ e ∈ mid :: tail | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type u_1
l₁ delim : List α
l₂ : List (List α)
hlen : length l₁ ≤ 1 + length delim
head mid : List α
tail : List (List α)
h : ∀ (e : List α), e ∈ head :: mid :: tail → ¬l₁ <:+: delim ++ e ++ delim
hne_nil : head :: mid :: tail ≠ []
hl : l₂ = head :: mid :: tail
contr : l₁ <:+: delim ++ (head ++ (delim ++ (join (intersperse delim (mid :: tail)) ++ delim)))
not_inf : ¬l₁ <:+: delim ++ head ++ delim
hge : 1 ≤ length l₁
hinf : l₁ <:+: drop (length delim + 1 - length l₁) delim ++ (intercalate delim (mid :: tail) ++ delim)
e : List α
ein : e ∈ mid :: tail
⊢ e = head ∨ e ∈ mid :: tail
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.