Module docstring
{"# Algebraic properties of tuples "}
{"# Algebraic properties of tuples "}
Fin.insertNth_one_right
      theorem
     [∀ j, One (α j)] (i : Fin (n + 1)) (x : α i) : i.insertNth x 1 = Pi.mulSingle i x
        @[to_additive (attr := simp)]
lemma insertNth_one_right [∀ j, One (α j)] (i : Fin (n + 1)) (x : α i) :
    i.insertNth x 1 = Pi.mulSingle i x :=
  insertNth_eq_iff.2 <| by unfold removeNth; simp [succAbove_ne, Pi.one_def]
        Fin.insertNth_mul
      theorem
     [∀ j, Mul (α j)] (i : Fin (n + 1)) (x y : α i) (p q : ∀ j, α (i.succAbove j)) :
  i.insertNth (x * y) (p * q) = i.insertNth x p * i.insertNth y q
        @[to_additive (attr := simp)]
lemma insertNth_mul [∀ j, Mul (α j)] (i : Fin (n + 1)) (x y : α i) (p q : ∀ j, α (i.succAbove j)) :
    i.insertNth (x * y) (p * q) = i.insertNth x p * i.insertNth y q :=
  insertNth_binop (fun _ ↦ (· * ·)) i x y p q
        Fin.insertNth_div
      theorem
     [∀ j, Div (α j)] (i : Fin (n + 1)) (x y : α i) (p q : ∀ j, α (i.succAbove j)) :
  i.insertNth (x / y) (p / q) = i.insertNth x p / i.insertNth y q
        @[to_additive (attr := simp)]
lemma insertNth_div [∀ j, Div (α j)] (i : Fin (n + 1)) (x y : α i)(p q : ∀ j, α (i.succAbove j)) :
    i.insertNth (x / y) (p / q) = i.insertNth x p / i.insertNth y q :=
  insertNth_binop (fun _ ↦ (· / ·)) i x y p q
        Fin.insertNth_div_same
      theorem
     [∀ j, Group (α j)] (i : Fin (n + 1)) (x y : α i) (p : ∀ j, α (i.succAbove j)) :
  i.insertNth x p / i.insertNth y p = Pi.mulSingle i (x / y)
        @[to_additive (attr := simp)]
lemma insertNth_div_same [∀ j, Group (α j)] (i : Fin (n + 1)) (x y : α i)
    (p : ∀ j, α (i.succAbove j)) : i.insertNth x p / i.insertNth y p = Pi.mulSingle i (x / y) := by
  simp_rw [← insertNth_div, ← insertNth_one_right, Pi.div_def, div_self', Pi.one_def]
        Matrix.smul_empty
      theorem
     (x : M) (v : Fin 0 → α) : x • v = ![]
        @[simp] lemma smul_empty (x : M) (v : Fin 0 → α) : x • v = ![] := empty_eq _
        Matrix.smul_cons
      theorem
     (x : M) (y : α) (v : Fin n → α) : x • vecCons y v = vecCons (x • y) (x • v)
        
      Matrix.empty_add_empty
      theorem
     (v w : Fin 0 → α) : v + w = ![]
        @[simp] lemma empty_add_empty (v w : Fin 0 → α) : v + w = ![] := empty_eq _
        Matrix.cons_add
      theorem
     (x : α) (v : Fin n → α) (w : Fin n.succ → α) : vecCons x v + w = vecCons (x + vecHead w) (v + vecTail w)
        
      Matrix.add_cons
      theorem
     (v : Fin n.succ → α) (y : α) (w : Fin n → α) : v + vecCons y w = vecCons (vecHead v + y) (vecTail v + w)
        
      Matrix.cons_add_cons
      theorem
     (x : α) (v : Fin n → α) (y : α) (w : Fin n → α) : vecCons x v + vecCons y w = vecCons (x + y) (v + w)
        
      Matrix.head_add
      theorem
     (a b : Fin n.succ → α) : vecHead (a + b) = vecHead a + vecHead b
        
      Matrix.tail_add
      theorem
     (a b : Fin n.succ → α) : vecTail (a + b) = vecTail a + vecTail b
        
      Matrix.empty_sub_empty
      theorem
     (v w : Fin 0 → α) : v - w = ![]
        @[simp] lemma empty_sub_empty (v w : Fin 0 → α) : v - w = ![] := empty_eq _
        Matrix.cons_sub
      theorem
     (x : α) (v : Fin n → α) (w : Fin n.succ → α) : vecCons x v - w = vecCons (x - vecHead w) (v - vecTail w)
        
      Matrix.sub_cons
      theorem
     (v : Fin n.succ → α) (y : α) (w : Fin n → α) : v - vecCons y w = vecCons (vecHead v - y) (vecTail v - w)
        
      Matrix.cons_sub_cons
      theorem
     (x : α) (v : Fin n → α) (y : α) (w : Fin n → α) : vecCons x v - vecCons y w = vecCons (x - y) (v - w)
        
      Matrix.head_sub
      theorem
     (a b : Fin n.succ → α) : vecHead (a - b) = vecHead a - vecHead b
        
      Matrix.tail_sub
      theorem
     (a b : Fin n.succ → α) : vecTail (a - b) = vecTail a - vecTail b
        
      Matrix.zero_empty
      theorem
     : (0 : Fin 0 → α) = ![]
        @[simp] lemma zero_empty : (0 : Fin 0 → α) = ![] := empty_eq _
        Matrix.cons_zero_zero
      theorem
     : vecCons (0 : α) (0 : Fin n → α) = 0
        @[simp] lemma cons_zero_zero : vecCons (0 : α) (0 : Fin n → α) = 0 := by
  ext i; exact i.cases rfl (by simp)
        Matrix.head_zero
      theorem
     : vecHead (0 : Fin n.succ → α) = 0
        
      Matrix.tail_zero
      theorem
     : vecTail (0 : Fin n.succ → α) = 0
        
      Matrix.cons_eq_zero_iff
      theorem
     {v : Fin n → α} {x : α} : vecCons x v = 0 ↔ x = 0 ∧ v = 0
        @[simp] lemma cons_eq_zero_iff {v : Fin n → α} {x : α} : vecConsvecCons x v = 0 ↔ x = 0 ∧ v = 0 where
  mp h := ⟨congr_fun h 0, by convert congr_arg vecTail h⟩
  mpr := fun ⟨hx, hv⟩ ↦ by simp [hx, hv]
        Matrix.cons_nonzero_iff
      theorem
     {v : Fin n → α} {x : α} : vecCons x v ≠ 0 ↔ x ≠ 0 ∨ v ≠ 0
        lemma cons_nonzero_iff {v : Fin n → α} {x : α} : vecConsvecCons x v ≠ 0vecCons x v ≠ 0 ↔ x ≠ 0 ∨ v ≠ 0 where
  mp h := not_and_or.mp (h ∘ cons_eq_zero_iff.mpr)
  mpr h := mt cons_eq_zero_iff.mp (not_and_or.mpr h)
        Matrix.neg_empty
      theorem
     (v : Fin 0 → α) : -v = ![]
        
      Matrix.neg_cons
      theorem
     (x : α) (v : Fin n → α) : -vecCons x v = vecCons (-x) (-v)
        
      Matrix.head_neg
      theorem
     (a : Fin n.succ → α) : vecHead (-a) = -vecHead a
        
      Matrix.tail_neg
      theorem
     (a : Fin n.succ → α) : vecTail (-a) = -vecTail a