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

tactic: ext i
state_before: α : Type u
m n o : ℕ
m' : Type ?u.42128
n' : Type ?u.42131
o' : Type ?u.42134
v : Fin (n + 1) → α
⊢ vecAlt1 (_ : n + 1 + (n + 1) = n + 1 + (n + 1)) (vecAppend (_ : n + 1 + (n + 1) = n + 1 + (n + 1)) v v) = v ∘ bit1

tactic: simp_rw [Function.comp, vecAlt1, vecAppend_eq_ite]
state_before: case h
α : Type u
m n o : ℕ
m' : Type ?u.42128
n' : Type ?u.42131
o' : Type ?u.42134
v : Fin (n + 1) → α
i : Fin (n + 1)
⊢ vecAlt1 (_ : n + 1 + (n + 1) = n + 1 + (n + 1)) (vecAppend (_ : n + 1 + (n + 1) = n + 1 + (n + 1)) v v) i =
    (v ∘ bit1) i

tactic: cases' i with i hi
state_before: case h.zero
α : Type u
m o : ℕ
m' : Type ?u.42128
n' : Type ?u.42131
o' : Type ?u.42134
v : Fin (Nat.zero + 1) → α
i : Fin (Nat.zero + 1)
⊢ (if h : ↑i + ↑i + 1 < Nat.zero + 1 then
      v
        { val := ↑i + ↑i + 1,
          isLt :=
            (_ : ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < Nat.zero + 1 + (Nat.zero + 1)) } < Nat.zero + 1) }
    else
      v
        { val := ↑i + ↑i + 1 - (Nat.zero + 1),
          isLt :=
            (_ :
              ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < Nat.zero + 1 + (Nat.zero + 1)) } - (Nat.zero + 1) <
                Nat.zero + 1) }) =
    v (bit1 i)

tactic: simp only [Nat.zero_eq, zero_add, Nat.lt_one_iff] at hi
state_before: case h.zero.mk
α : Type u
m o : ℕ
m' : Type ?u.42128
n' : Type ?u.42131
o' : Type ?u.42134
v : Fin (Nat.zero + 1) → α
i : ℕ
hi : i < Nat.zero + 1
⊢ (if h : ↑{ val := i, isLt := hi } + ↑{ val := i, isLt := hi } + 1 < Nat.zero + 1 then
      v
        { val := ↑{ val := i, isLt := hi } + ↑{ val := i, isLt := hi } + 1,
          isLt :=
            (_ :
              ↑{ val := ↑{ val := i, isLt := hi } + ↑{ val := i, isLt := hi } + 1,
                    isLt :=
                      (_ :
                        ↑{ val := i, isLt := hi } + ↑{ val := i, isLt := hi } + 1 < Nat.zero + 1 + (Nat.zero + 1)) } <
                Nat.zero + 1) }
    else
      v
        { val := ↑{ val := i, isLt := hi } + ↑{ val := i, isLt := hi } + 1 - (Nat.zero + 1),
          isLt :=
            (_ :
              ↑{ val := ↑{ val := i, isLt := hi } + ↑{ val := i, isLt := hi } + 1,
                      isLt :=
                        (_ :
                          ↑{ val := i, isLt := hi } + ↑{ val := i, isLt := hi } + 1 < Nat.zero + 1 + (Nat.zero + 1)) } -
                  (Nat.zero + 1) <
                Nat.zero + 1) }) =
    v (bit1 { val := i, isLt := hi })

tactic: subst i
state_before: case h.zero.mk
α : Type u
m o : ℕ
m' : Type ?u.42128
n' : Type ?u.42131
o' : Type ?u.42134
v : Fin (Nat.zero + 1) → α
i : ℕ
hi✝ : i < Nat.zero + 1
hi : i = 0
⊢ (if h : ↑{ val := i, isLt := hi✝ } + ↑{ val := i, isLt := hi✝ } + 1 < Nat.zero + 1 then
      v
        { val := ↑{ val := i, isLt := hi✝ } + ↑{ val := i, isLt := hi✝ } + 1,
          isLt :=
            (_ :
              ↑{ val := ↑{ val := i, isLt := hi✝ } + ↑{ val := i, isLt := hi✝ } + 1,
                    isLt :=
                      (_ :
                        ↑{ val := i, isLt := hi✝ } + ↑{ val := i, isLt := hi✝ } + 1 < Nat.zero + 1 + (Nat.zero + 1)) } <
                Nat.zero + 1) }
    else
      v
        { val := ↑{ val := i, isLt := hi✝ } + ↑{ val := i, isLt := hi✝ } + 1 - (Nat.zero + 1),
          isLt :=
            (_ :
              ↑{ val := ↑{ val := i, isLt := hi✝ } + ↑{ val := i, isLt := hi✝ } + 1,
                      isLt :=
                        (_ :
                          ↑{ val := i, isLt := hi✝ } + ↑{ val := i, isLt := hi✝ } + 1 <
                            Nat.zero + 1 + (Nat.zero + 1)) } -
                  (Nat.zero + 1) <
                Nat.zero + 1) }) =
    v (bit1 { val := i, isLt := hi✝ })

tactic: rfl
state_before: case h.zero.mk
α : Type u
m o : ℕ
m' : Type ?u.42128
n' : Type ?u.42131
o' : Type ?u.42134
v : Fin (Nat.zero + 1) → α
hi : 0 < Nat.zero + 1
⊢ (if h : ↑{ val := 0, isLt := hi } + ↑{ val := 0, isLt := hi } + 1 < Nat.zero + 1 then
      v
        { val := ↑{ val := 0, isLt := hi } + ↑{ val := 0, isLt := hi } + 1,
          isLt :=
            (_ :
              ↑{ val := ↑{ val := 0, isLt := hi } + ↑{ val := 0, isLt := hi } + 1,
                    isLt :=
                      (_ :
                        ↑{ val := 0, isLt := hi } + ↑{ val := 0, isLt := hi } + 1 < Nat.zero + 1 + (Nat.zero + 1)) } <
                Nat.zero + 1) }
    else
      v
        { val := ↑{ val := 0, isLt := hi } + ↑{ val := 0, isLt := hi } + 1 - (Nat.zero + 1),
          isLt :=
            (_ :
              ↑{ val := ↑{ val := 0, isLt := hi } + ↑{ val := 0, isLt := hi } + 1,
                      isLt :=
                        (_ :
                          ↑{ val := 0, isLt := hi } + ↑{ val := 0, isLt := hi } + 1 < Nat.zero + 1 + (Nat.zero + 1)) } -
                  (Nat.zero + 1) <
                Nat.zero + 1) }) =
    v (bit1 { val := 0, isLt := hi })

tactic: split_ifs with h <;> simp_rw [bit1, bit0] <;> congr
state_before: case h.succ
α : Type u
m o : ℕ
m' : Type ?u.42128
n' : Type ?u.42131
o' : Type ?u.42134
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
⊢ (if h : ↑i + ↑i + 1 < Nat.succ n + 1 then
      v
        { val := ↑i + ↑i + 1,
          isLt :=
            (_ :
              ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < Nat.succ n + 1 + (Nat.succ n + 1)) } < Nat.succ n + 1) }
    else
      v
        { val := ↑i + ↑i + 1 - (Nat.succ n + 1),
          isLt :=
            (_ :
              ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < Nat.succ n + 1 + (Nat.succ n + 1)) } -
                  (Nat.succ n + 1) <
                Nat.succ n + 1) }) =
    v (bit1 i)

tactic: simp only [Fin.ext_iff, Fin.val_add, Fin.val_mk]
state_before: case h.succ.inl.e_a.e_val
α : Type u
m o : ℕ
m' : Type ?u.42128
n' : Type ?u.42131
o' : Type ?u.42134
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : ↑i + ↑i + 1 < Nat.succ n + 1
⊢ ↑i + ↑i + 1 = ((↑i + ↑i) % (Nat.succ n + 1) + 1 % (Nat.succ n + 1)) % (Nat.succ n + 1)

tactic: rw [Fin.val_mk] at h
state_before: case h.succ.inl.e_a.e_val
α : Type u
m o : ℕ
m' : Type ?u.42128
n' : Type ?u.42131
o' : Type ?u.42134
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : ↑i + ↑i + 1 < Nat.succ n + 1
⊢ ↑i + ↑i + 1 = ((↑i + ↑i) % (Nat.succ n + 1) + 1 % (Nat.succ n + 1)) % (Nat.succ n + 1)

tactic: erw [Nat.mod_eq_of_lt (Nat.lt_of_succ_lt h)]
state_before: case h.succ.inl.e_a.e_val
α : Type u
m o : ℕ
m' : Type ?u.42128
n' : Type ?u.42131
o' : Type ?u.42134
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : ↑i + ↑i + 1 < Nat.succ n + 1
⊢ ↑i + ↑i + 1 = ((↑i + ↑i) % (Nat.succ n + 1) + 1 % (Nat.succ n + 1)) % (Nat.succ n + 1)

tactic: erw [Nat.mod_eq_of_lt h]
state_before: case h.succ.inl.e_a.e_val
α : Type u
m o : ℕ
m' : Type ?u.42128
n' : Type ?u.42131
o' : Type ?u.42134
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : ↑i + ↑i + 1 < Nat.succ n + 1
⊢ ↑i + ↑i + 1 = (↑i + ↑i + 1 % (Nat.succ n + 1)) % (Nat.succ n + 1)

tactic: rw [Fin.val_mk, not_lt] at h
state_before: case h.succ.inr.e_a.e_val
α : Type u
m o : ℕ
m' : Type ?u.42128
n' : Type ?u.42131
o' : Type ?u.42134
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : ¬↑i + ↑i + 1 < Nat.succ n + 1
⊢ ↑i + ↑i + 1 - (Nat.succ n + 1) = ((↑i + ↑i) % (Nat.succ n + 1) + 1 % (Nat.succ n + 1)) % (Nat.succ n + 1)

tactic: simp only [Fin.ext_iff, Fin.val_add, Fin.val_mk, Nat.mod_add_mod, Fin.val_one,
  Nat.mod_eq_sub_mod h, show 1 % (n + 2) = 1 from Nat.mod_eq_of_lt (by simp)]
state_before: case h.succ.inr.e_a.e_val
α : Type u
m o : ℕ
m' : Type ?u.42128
n' : Type ?u.42131
o' : Type ?u.42134
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : Nat.succ n + 1 ≤ ↑i + ↑i + 1
⊢ ↑i + ↑i + 1 - (Nat.succ n + 1) = ((↑i + ↑i) % (Nat.succ n + 1) + 1 % (Nat.succ n + 1)) % (Nat.succ n + 1)

tactic: refine (Nat.mod_eq_of_lt ?_).symm
state_before: case h.succ.inr.e_a.e_val
α : Type u
m o : ℕ
m' : Type ?u.42128
n' : Type ?u.42131
o' : Type ?u.42134
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : Nat.succ n + 1 ≤ ↑i + ↑i + 1
⊢ ↑i + ↑i + 1 - (Nat.succ n + 1) = (↑i + ↑i + 1 - (Nat.succ n + 1)) % (Nat.succ n + 1)

tactic: rw [tsub_lt_iff_left h]
state_before: case h.succ.inr.e_a.e_val
α : Type u
m o : ℕ
m' : Type ?u.42128
n' : Type ?u.42131
o' : Type ?u.42134
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : Nat.succ n + 1 ≤ ↑i + ↑i + 1
⊢ ↑i + ↑i + 1 - (Nat.succ n + 1) < Nat.succ n + 1

tactic: exact Nat.add_succ_lt_add i.2 i.2
state_before: case h.succ.inr.e_a.e_val
α : Type u
m o : ℕ
m' : Type ?u.42128
n' : Type ?u.42131
o' : Type ?u.42134
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : Nat.succ n + 1 ≤ ↑i + ↑i + 1
⊢ ↑i + ↑i + 1 < Nat.succ n + 1 + (Nat.succ n + 1)

tactic: simp
state_before: α : Type u
m o : ℕ
m' : Type ?u.42128
n' : Type ?u.42131
o' : Type ?u.42134
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : Nat.succ n + 1 ≤ ↑i + ↑i + 1
⊢ 1 < n + 2