Theorem: Matrix.cons_vecAppend
File: Mathlib/Data/Fin/VecNotation.lean

tactic: rwa [add_assoc, add_comm 1, ← add_assoc, add_right_cancel_iff] at ho
state_before: α : Type u
m n o : ℕ
m' : Type ?u.28987
n' : Type ?u.28990
o' : Type ?u.28993
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
⊢ o = m + n

tactic: ext i
state_before: α : Type u
m n o : ℕ
m' : Type ?u.28987
n' : Type ?u.28990
o' : Type ?u.28993
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
⊢ vecAppend ho (vecCons x u) v = vecCons x (vecAppend (_ : o = m + n) u v)

tactic: simp_rw [vecAppend_eq_ite]
state_before: case h
α : Type u
m n o : ℕ
m' : Type ?u.28987
n' : Type ?u.28990
o' : Type ?u.28993
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
i : Fin (o + 1)
⊢ vecAppend ho (vecCons x u) v i = vecCons x (vecAppend (_ : o = m + n) u v) i

tactic: split_ifs with h
state_before: case h
α : Type u
m n o : ℕ
m' : Type ?u.28987
n' : Type ?u.28990
o' : Type ?u.28993
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
i : Fin (o + 1)
⊢ (if h : ↑i < m + 1 then vecCons x u { val := ↑i, isLt := h }
    else v { val := ↑i - (m + 1), isLt := (_ : ↑i - (m + 1) < n) }) =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) }) i

tactic: rcases i with ⟨⟨⟩ | i, hi⟩
state_before: case h.inl
α : Type u
m n o : ℕ
m' : Type ?u.28987
n' : Type ?u.28990
o' : Type ?u.28993
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
i : Fin (o + 1)
h : ↑i < m + 1
⊢ vecCons x u { val := ↑i, isLt := h } =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) }) i

tactic: simp
state_before: case h.inl.mk.zero
α : Type u
m n o : ℕ
m' : Type ?u.28987
n' : Type ?u.28990
o' : Type ?u.28993
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
hi : Nat.zero < o + 1
h : ↑{ val := Nat.zero, isLt := hi } < m + 1
⊢ vecCons x u { val := ↑{ val := Nat.zero, isLt := hi }, isLt := h } =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) })
      { val := Nat.zero, isLt := hi }

tactic: simp only [Nat.succ_eq_add_one, add_lt_add_iff_right, Fin.val_mk] at h
state_before: case h.inl.mk.succ
α : Type u
m n o : ℕ
m' : Type ?u.28987
n' : Type ?u.28990
o' : Type ?u.28993
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
i : ℕ
hi : Nat.succ i < o + 1
h : ↑{ val := Nat.succ i, isLt := hi } < m + 1
⊢ vecCons x u { val := ↑{ val := Nat.succ i, isLt := hi }, isLt := h } =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) })
      { val := Nat.succ i, isLt := hi }

tactic: simp [h]
state_before: case h.inl.mk.succ
α : Type u
m n o : ℕ
m' : Type ?u.28987
n' : Type ?u.28990
o' : Type ?u.28993
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
i : ℕ
hi : Nat.succ i < o + 1
h✝ : ↑{ val := Nat.succ i, isLt := hi } < m + 1
h : i < m
⊢ vecCons x u { val := ↑{ val := Nat.succ i, isLt := hi }, isLt := h✝ } =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) })
      { val := Nat.succ i, isLt := hi }

tactic: rcases i with ⟨⟨⟩ | i, hi⟩
state_before: case h.inr
α : Type u
m n o : ℕ
m' : Type ?u.28987
n' : Type ?u.28990
o' : Type ?u.28993
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
i : Fin (o + 1)
h : ¬↑i < m + 1
⊢ v { val := ↑i - (m + 1), isLt := (_ : ↑i - (m + 1) < n) } =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) }) i

tactic: simp at h
state_before: case h.inr.mk.zero
α : Type u
m n o : ℕ
m' : Type ?u.28987
n' : Type ?u.28990
o' : Type ?u.28993
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
hi : Nat.zero < o + 1
h : ¬↑{ val := Nat.zero, isLt := hi } < m + 1
⊢ v
      { val := ↑{ val := Nat.zero, isLt := hi } - (m + 1),
        isLt := (_ : ↑{ val := Nat.zero, isLt := hi } - (m + 1) < n) } =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) })
      { val := Nat.zero, isLt := hi }

tactic: rw [not_lt, Fin.val_mk, Nat.succ_eq_add_one, add_le_add_iff_right] at h
state_before: case h.inr.mk.succ
α : Type u
m n o : ℕ
m' : Type ?u.28987
n' : Type ?u.28990
o' : Type ?u.28993
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
i : ℕ
hi : Nat.succ i < o + 1
h : ¬↑{ val := Nat.succ i, isLt := hi } < m + 1
⊢ v
      { val := ↑{ val := Nat.succ i, isLt := hi } - (m + 1),
        isLt := (_ : ↑{ val := Nat.succ i, isLt := hi } - (m + 1) < n) } =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) })
      { val := Nat.succ i, isLt := hi }

tactic: simp [h, not_lt.2 h]
state_before: case h.inr.mk.succ
α : Type u
m n o : ℕ
m' : Type ?u.28987
n' : Type ?u.28990
o' : Type ?u.28993
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
i : ℕ
hi : Nat.succ i < o + 1
h✝ : ¬↑{ val := Nat.succ i, isLt := hi } < m + 1
h : m ≤ i
⊢ v
      { val := ↑{ val := Nat.succ i, isLt := hi } - (m + 1),
        isLt := (_ : ↑{ val := Nat.succ i, isLt := hi } - (m + 1) < n) } =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) })
      { val := Nat.succ i, isLt := hi }