Theorem: List.nthLe_succ_scanl
File: Mathlib/Data/List/Basic.lean

tactic: cases l
state_before: case zero
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
b : β
l : List α
h : 0 + 1 < (scanl f b l).length
⊢ (scanl f b l).nthLe (0 + 1) h = f ((scanl f b l).nthLe 0 ⋯) (l.nthLe 0 ⋯)
state_after: case zero.nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
b : β
h : 0 + 1 < (scanl f b []).length
⊢ (scanl f b []).nthLe (0 + 1) h = f ((scanl f b []).nthLe 0 ⋯) ([].nthLe 0 ⋯)

case zero.cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
b : β
head✝ : α
tail✝ : List α
h : 0 + 1 < (scanl f b (head✝ :: tail✝)).length
⊢ (scanl f b (head✝ :: tail✝)).nthLe (0 + 1) h = f ((scanl f b (head✝ :: tail✝)).nthLe 0 ⋯) ((head✝ :: tail✝).nthLe 0 ⋯)

tactic: simp only [length, zero_eq, lt_self_iff_false] at h
state_before: case zero.nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
b : β
h : 0 + 1 < (scanl f b []).length
⊢ (scanl f b []).nthLe (0 + 1) h = f ((scanl f b []).nthLe 0 ⋯) ([].nthLe 0 ⋯)
state_after: no goals

tactic: simp [scanl_cons, singleton_append, nthLe_zero_scanl, nthLe_cons]
state_before: case zero.cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
b : β
head✝ : α
tail✝ : List α
h : 0 + 1 < (scanl f b (head✝ :: tail✝)).length
⊢ (scanl f b (head✝ :: tail✝)).nthLe (0 + 1) h = f ((scanl f b (head✝ :: tail✝)).nthLe 0 ⋯) ((head✝ :: tail✝).nthLe 0 ⋯)
state_after: no goals

tactic: cases l
state_before: case succ
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
l : List α
h : i + 1 + 1 < (scanl f b l).length
⊢ (scanl f b l).nthLe (i + 1 + 1) h = f ((scanl f b l).nthLe (i + 1) ⋯) (l.nthLe (i + 1) ⋯)
state_after: case succ.nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
h : i + 1 + 1 < (scanl f b []).length
⊢ (scanl f b []).nthLe (i + 1 + 1) h = f ((scanl f b []).nthLe (i + 1) ⋯) ([].nthLe (i + 1) ⋯)

case succ.cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
head✝ : α
tail✝ : List α
h : i + 1 + 1 < (scanl f b (head✝ :: tail✝)).length
⊢ (scanl f b (head✝ :: tail✝)).nthLe (i + 1 + 1) h =
    f ((scanl f b (head✝ :: tail✝)).nthLe (i + 1) ⋯) ((head✝ :: tail✝).nthLe (i + 1) ⋯)

tactic: simp only [length] at h
state_before: case succ.nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
h : i + 1 + 1 < (scanl f b []).length
⊢ (scanl f b []).nthLe (i + 1 + 1) h = f ((scanl f b []).nthLe (i + 1) ⋯) ([].nthLe (i + 1) ⋯)
state_after: case succ.nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
h : i + 1 + 1 < 0 + 1
⊢ (scanl f b []).nthLe (i + 1 + 1) h = f ((scanl f b []).nthLe (i + 1) ⋯) ([].nthLe (i + 1) ⋯)

tactic: exact absurd h (by omega)
state_before: case succ.nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
h : i + 1 + 1 < 0 + 1
⊢ (scanl f b []).nthLe (i + 1 + 1) h = f ((scanl f b []).nthLe (i + 1) ⋯) ([].nthLe (i + 1) ⋯)
state_after: no goals

tactic: omega
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
h : i + 1 + 1 < 0 + 1
⊢ ¬i + 1 + 1 < 0 + 1
state_after: no goals

tactic: simp_rw [scanl_cons]
state_before: case succ.cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
head✝ : α
tail✝ : List α
h : i + 1 + 1 < (scanl f b (head✝ :: tail✝)).length
⊢ (scanl f b (head✝ :: tail✝)).nthLe (i + 1 + 1) h =
    f ((scanl f b (head✝ :: tail✝)).nthLe (i + 1) ⋯) ((head✝ :: tail✝).nthLe (i + 1) ⋯)
state_after: case succ.cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
head✝ : α
tail✝ : List α
h : i + 1 + 1 < (scanl f b (head✝ :: tail✝)).length
⊢ ([b] ++ scanl f (f b head✝) tail✝).nthLe (i + 1 + 1) ⋯ =
    f (([b] ++ scanl f (f b head✝) tail✝).nthLe (i + 1) ⋯) ((head✝ :: tail✝).nthLe (i + 1) ⋯)

tactic: rw [nthLe_append_right]
state_before: case succ.cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
head✝ : α
tail✝ : List α
h : i + 1 + 1 < (scanl f b (head✝ :: tail✝)).length
⊢ ([b] ++ scanl f (f b head✝) tail✝).nthLe (i + 1 + 1) ⋯ =
    f (([b] ++ scanl f (f b head✝) tail✝).nthLe (i + 1) ⋯) ((head✝ :: tail✝).nthLe (i + 1) ⋯)
state_after: case succ.cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
head✝ : α
tail✝ : List α
h : i + 1 + 1 < (scanl f b (head✝ :: tail✝)).length
⊢ (scanl f (f b head✝) tail✝).nthLe (i + 1 + 1 - [b].length) ⋯ =
    f (([b] ++ scanl f (f b head✝) tail✝).nthLe (i + 1) ⋯) ((head✝ :: tail✝).nthLe (i + 1) ⋯)

case succ.cons.h₁
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
head✝ : α
tail✝ : List α
h : i + 1 + 1 < (scanl f b (head✝ :: tail✝)).length
⊢ [b].length ≤ i + 1 + 1

tactic: simp only [length, Nat.zero_add 1, succ_add_sub_one, hi]
state_before: case succ.cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
head✝ : α
tail✝ : List α
h : i + 1 + 1 < (scanl f b (head✝ :: tail✝)).length
⊢ (scanl f (f b head✝) tail✝).nthLe (i + 1 + 1 - [b].length) ⋯ =
    f (([b] ++ scanl f (f b head✝) tail✝).nthLe (i + 1) ⋯) ((head✝ :: tail✝).nthLe (i + 1) ⋯)
state_after: case succ.cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
head✝ : α
tail✝ : List α
h : i + 1 + 1 < (scanl f b (head✝ :: tail✝)).length
⊢ f ((scanl f (f b head✝) tail✝).nthLe i ⋯) (tail✝.nthLe i ⋯) =
    f (([b] ++ scanl f (f b head✝) tail✝).nthLe (i + 1) ⋯) ((head✝ :: tail✝).nthLe (i + 1) ⋯)

tactic: rfl
state_before: case succ.cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
head✝ : α
tail✝ : List α
h : i + 1 + 1 < (scanl f b (head✝ :: tail✝)).length
⊢ f ((scanl f (f b head✝) tail✝).nthLe i ⋯) (tail✝.nthLe i ⋯) =
    f (([b] ++ scanl f (f b head✝) tail✝).nthLe (i + 1) ⋯) ((head✝ :: tail✝).nthLe (i + 1) ⋯)
state_after: no goals

tactic: simp only [length_singleton]
state_before: case succ.cons.h₁
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
head✝ : α
tail✝ : List α
h : i + 1 + 1 < (scanl f b (head✝ :: tail✝)).length
⊢ [b].length ≤ i + 1 + 1
state_after: case succ.cons.h₁
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
head✝ : α
tail✝ : List α
h : i + 1 + 1 < (scanl f b (head✝ :: tail✝)).length
⊢ 1 ≤ i + 1 + 1

tactic: omega
state_before: case succ.cons.h₁
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
i : ℕ
hi :
  ∀ {b : β} {l : List α} {h : i + 1 < (scanl f b l).length},
    (scanl f b l).nthLe (i + 1) h = f ((scanl f b l).nthLe i ⋯) (l.nthLe i ⋯)
b : β
head✝ : α
tail✝ : List α
h : i + 1 + 1 < (scanl f b (head✝ :: tail✝)).length
⊢ 1 ≤ i + 1 + 1
state_after: no goals