Theorem: List.get?_succ_scanl
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with hd tl hl generalizing b i
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
b : β
a : α
l : List α
i : ℕ
⊢ (scanl f b l).get? (i + 1) = ((scanl f b l).get? i).bind fun x => Option.map (fun y => f x y) (l.get? i)
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
b : β
i : ℕ
⊢ (scanl f b []).get? (i + 1) = ((scanl f b []).get? i).bind fun x => Option.map (fun y => f x y) ([].get? i)

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a hd : α
tl : List α
hl :
  ∀ {b : β} {i : ℕ},
    (scanl f b tl).get? (i + 1) = ((scanl f b tl).get? i).bind fun x => Option.map (fun y => f x y) (tl.get? i)
b : β
i : ℕ
⊢ (scanl f b (hd :: tl)).get? (i + 1) =
    ((scanl f b (hd :: tl)).get? i).bind fun x => Option.map (fun y => f x y) ((hd :: tl).get? i)

tactic: symm
state_before: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
b : β
i : ℕ
⊢ (scanl f b []).get? (i + 1) = ((scanl f b []).get? i).bind fun x => Option.map (fun y => f x y) ([].get? i)
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
b : β
i : ℕ
⊢ (((scanl f b []).get? i).bind fun x => Option.map (fun y => f x y) ([].get? i)) = (scanl f b []).get? (i + 1)

tactic: simp only [Option.bind_eq_none', get?, forall₂_true_iff, not_false_iff, Option.map_none',
  scanl_nil, Option.not_mem_none, forall_true_iff]
state_before: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a : α
b : β
i : ℕ
⊢ (((scanl f b []).get? i).bind fun x => Option.map (fun y => f x y) ([].get? i)) = (scanl f b []).get? (i + 1)
state_after: no goals

tactic: simp only [scanl_cons, singleton_append]
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a hd : α
tl : List α
hl :
  ∀ {b : β} {i : ℕ},
    (scanl f b tl).get? (i + 1) = ((scanl f b tl).get? i).bind fun x => Option.map (fun y => f x y) (tl.get? i)
b : β
i : ℕ
⊢ (scanl f b (hd :: tl)).get? (i + 1) =
    ((scanl f b (hd :: tl)).get? i).bind fun x => Option.map (fun y => f x y) ((hd :: tl).get? i)
state_after: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a hd : α
tl : List α
hl :
  ∀ {b : β} {i : ℕ},
    (scanl f b tl).get? (i + 1) = ((scanl f b tl).get? i).bind fun x => Option.map (fun y => f x y) (tl.get? i)
b : β
i : ℕ
⊢ (b :: scanl f (f b hd) tl).get? (i + 1) =
    ((b :: scanl f (f b hd) tl).get? i).bind fun a => Option.map (fun y => f a y) ((hd :: tl).get? i)

tactic: cases i
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a hd : α
tl : List α
hl :
  ∀ {b : β} {i : ℕ},
    (scanl f b tl).get? (i + 1) = ((scanl f b tl).get? i).bind fun x => Option.map (fun y => f x y) (tl.get? i)
b : β
i : ℕ
⊢ (b :: scanl f (f b hd) tl).get? (i + 1) =
    ((b :: scanl f (f b hd) tl).get? i).bind fun a => Option.map (fun y => f a y) ((hd :: tl).get? i)
state_after: case cons.zero
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a hd : α
tl : List α
hl :
  ∀ {b : β} {i : ℕ},
    (scanl f b tl).get? (i + 1) = ((scanl f b tl).get? i).bind fun x => Option.map (fun y => f x y) (tl.get? i)
b : β
⊢ (b :: scanl f (f b hd) tl).get? (0 + 1) =
    ((b :: scanl f (f b hd) tl).get? 0).bind fun a => Option.map (fun y => f a y) ((hd :: tl).get? 0)

case cons.succ
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a hd : α
tl : List α
hl :
  ∀ {b : β} {i : ℕ},
    (scanl f b tl).get? (i + 1) = ((scanl f b tl).get? i).bind fun x => Option.map (fun y => f x y) (tl.get? i)
b : β
n✝ : ℕ
⊢ (b :: scanl f (f b hd) tl).get? (n✝ + 1 + 1) =
    ((b :: scanl f (f b hd) tl).get? (n✝ + 1)).bind fun a => Option.map (fun y => f a y) ((hd :: tl).get? (n✝ + 1))

tactic: simp
state_before: case cons.zero
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a hd : α
tl : List α
hl :
  ∀ {b : β} {i : ℕ},
    (scanl f b tl).get? (i + 1) = ((scanl f b tl).get? i).bind fun x => Option.map (fun y => f x y) (tl.get? i)
b : β
⊢ (b :: scanl f (f b hd) tl).get? (0 + 1) =
    ((b :: scanl f (f b hd) tl).get? 0).bind fun a => Option.map (fun y => f a y) ((hd :: tl).get? 0)
state_after: no goals

tactic: simp only [hl, get?]
state_before: case cons.succ
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
a hd : α
tl : List α
hl :
  ∀ {b : β} {i : ℕ},
    (scanl f b tl).get? (i + 1) = ((scanl f b tl).get? i).bind fun x => Option.map (fun y => f x y) (tl.get? i)
b : β
n✝ : ℕ
⊢ (b :: scanl f (f b hd) tl).get? (n✝ + 1 + 1) =
    ((b :: scanl f (f b hd) tl).get? (n✝ + 1)).bind fun a => Option.map (fun y => f a y) ((hd :: tl).get? (n✝ + 1))
state_after: no goals