Theorem: Vector.scanl_get
File: Mathlib/Data/Vector/Basic.lean

tactic: cases' n with n
state_before: n : ℕ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α n
i : Fin n
⊢ (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
state_after: case zero
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α 0
i : Fin 0
⊢ (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)

case succ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
n : ℕ
v : Vector α (n + 1)
i : Fin (n + 1)
⊢ (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)

tactic: induction' n with n hn generalizing b
state_before: case succ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
n : ℕ
v : Vector α (n + 1)
i : Fin (n + 1)
⊢ (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
state_after: case succ.zero
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α (0 + 1)
i : Fin (0 + 1)
⊢ (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)

case succ.succ
α : Type u_1
β : Type u_2
f : β → α → β
n : ℕ
hn :
  ∀ (b : β) (v : Vector α (n + 1)) (i : Fin (n + 1)),
    (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
b : β
v : Vector α (n + 1 + 1)
i : Fin (n + 1 + 1)
⊢ (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)

tactic: exact i.elim0
state_before: case zero
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α 0
i : Fin 0
⊢ (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
state_after: no goals

tactic: have i0 : i = 0 := Fin.eq_zero _
state_before: case succ.zero
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α (0 + 1)
i : Fin (0 + 1)
⊢ (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
state_after: case succ.zero
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α (0 + 1)
i : Fin (0 + 1)
i0 : i = 0
⊢ (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)

tactic: simp [scanl_singleton, i0, get_zero]
state_before: case succ.zero
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α (0 + 1)
i : Fin (0 + 1)
i0 : i = 0
⊢ (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
state_after: case succ.zero
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α (0 + 1)
i : Fin (0 + 1)
i0 : i = 0
⊢ (b ::ᵥ f b v.head ::ᵥ nil).get 1 = f b v.head

tactic: simp [get_eq_get, List.get]
state_before: case succ.zero
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α (0 + 1)
i : Fin (0 + 1)
i0 : i = 0
⊢ (b ::ᵥ f b v.head ::ᵥ nil).get 1 = f b v.head
state_after: no goals

tactic: rw [← cons_head_tail v, scanl_cons, get_cons_succ]
state_before: case succ.succ
α : Type u_1
β : Type u_2
f : β → α → β
n : ℕ
hn :
  ∀ (b : β) (v : Vector α (n + 1)) (i : Fin (n + 1)),
    (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
b : β
v : Vector α (n + 1 + 1)
i : Fin (n + 1 + 1)
⊢ (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
state_after: case succ.succ
α : Type u_1
β : Type u_2
f : β → α → β
n : ℕ
hn :
  ∀ (b : β) (v : Vector α (n + 1)) (i : Fin (n + 1)),
    (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
b : β
v : Vector α (n + 1 + 1)
i : Fin (n + 1 + 1)
⊢ (scanl f (f b v.head) v.tail).get i =
    f ((b ::ᵥ scanl f (f b v.head) v.tail).get i.castSucc) ((v.head ::ᵥ v.tail).get i)

tactic: refine Fin.cases ?_ ?_ i
state_before: case succ.succ
α : Type u_1
β : Type u_2
f : β → α → β
n : ℕ
hn :
  ∀ (b : β) (v : Vector α (n + 1)) (i : Fin (n + 1)),
    (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
b : β
v : Vector α (n + 1 + 1)
i : Fin (n + 1 + 1)
⊢ (scanl f (f b v.head) v.tail).get i =
    f ((b ::ᵥ scanl f (f b v.head) v.tail).get i.castSucc) ((v.head ::ᵥ v.tail).get i)
state_after: case succ.succ.refine_1
α : Type u_1
β : Type u_2
f : β → α → β
n : ℕ
hn :
  ∀ (b : β) (v : Vector α (n + 1)) (i : Fin (n + 1)),
    (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
b : β
v : Vector α (n + 1 + 1)
i : Fin (n + 1 + 1)
⊢ (scanl f (f b v.head) v.tail).get 0 =
    f ((b ::ᵥ scanl f (f b v.head) v.tail).get (Fin.castSucc 0)) ((v.head ::ᵥ v.tail).get 0)

case succ.succ.refine_2
α : Type u_1
β : Type u_2
f : β → α → β
n : ℕ
hn :
  ∀ (b : β) (v : Vector α (n + 1)) (i : Fin (n + 1)),
    (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
b : β
v : Vector α (n + 1 + 1)
i : Fin (n + 1 + 1)
⊢ ∀ (i : Fin (n + 1)),
    (scanl f (f b v.head) v.tail).get i.succ =
      f ((b ::ᵥ scanl f (f b v.head) v.tail).get i.succ.castSucc) ((v.head ::ᵥ v.tail).get i.succ)

tactic: simp only [get_zero, scanl_head, Fin.castSucc_zero, head_cons]
state_before: case succ.succ.refine_1
α : Type u_1
β : Type u_2
f : β → α → β
n : ℕ
hn :
  ∀ (b : β) (v : Vector α (n + 1)) (i : Fin (n + 1)),
    (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
b : β
v : Vector α (n + 1 + 1)
i : Fin (n + 1 + 1)
⊢ (scanl f (f b v.head) v.tail).get 0 =
    f ((b ::ᵥ scanl f (f b v.head) v.tail).get (Fin.castSucc 0)) ((v.head ::ᵥ v.tail).get 0)
state_after: no goals

tactic: intro i'
state_before: case succ.succ.refine_2
α : Type u_1
β : Type u_2
f : β → α → β
n : ℕ
hn :
  ∀ (b : β) (v : Vector α (n + 1)) (i : Fin (n + 1)),
    (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
b : β
v : Vector α (n + 1 + 1)
i : Fin (n + 1 + 1)
⊢ ∀ (i : Fin (n + 1)),
    (scanl f (f b v.head) v.tail).get i.succ =
      f ((b ::ᵥ scanl f (f b v.head) v.tail).get i.succ.castSucc) ((v.head ::ᵥ v.tail).get i.succ)
state_after: case succ.succ.refine_2
α : Type u_1
β : Type u_2
f : β → α → β
n : ℕ
hn :
  ∀ (b : β) (v : Vector α (n + 1)) (i : Fin (n + 1)),
    (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
b : β
v : Vector α (n + 1 + 1)
i : Fin (n + 1 + 1)
i' : Fin (n + 1)
⊢ (scanl f (f b v.head) v.tail).get i'.succ =
    f ((b ::ᵥ scanl f (f b v.head) v.tail).get i'.succ.castSucc) ((v.head ::ᵥ v.tail).get i'.succ)

tactic: simp only [hn, Fin.castSucc_fin_succ, get_cons_succ]
state_before: case succ.succ.refine_2
α : Type u_1
β : Type u_2
f : β → α → β
n : ℕ
hn :
  ∀ (b : β) (v : Vector α (n + 1)) (i : Fin (n + 1)),
    (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
b : β
v : Vector α (n + 1 + 1)
i : Fin (n + 1 + 1)
i' : Fin (n + 1)
⊢ (scanl f (f b v.head) v.tail).get i'.succ =
    f ((b ::ᵥ scanl f (f b v.head) v.tail).get i'.succ.castSucc) ((v.head ::ᵥ v.tail).get i'.succ)
state_after: no goals