File: Mathlib/Algebra/Group/Fin/Tuple.lean

full_name: Fin.insertNth_one_right
code: @[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 
goal: i.insertNth x 1 = Pi.mulSingle i x

full_name: Fin.insertNth_zero_right
code: @[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 
goal: i.insertNth x 0 = Pi.single i x

full_name: Fin.insertNth_mul
code: @[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 
goal: i.insertNth (x * y) (p * q) = i.insertNth x p * i.insertNth y q

full_name: Fin.insertNth_add
code: @[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 
goal: i.insertNth (x + y) (p + q) = i.insertNth x p + i.insertNth y q

full_name: Fin.insertNth_div
code: @[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 
goal: i.insertNth (x / y) (p / q) = i.insertNth x p / i.insertNth y q

full_name: Fin.insertNth_sub
code: @[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 
goal: i.insertNth (x - y) (p - q) = i.insertNth x p - i.insertNth y q

full_name: Fin.insertNth_sub_same
code: @[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) 
goal: i.insertNth x p - i.insertNth y p = Pi.single i (x - y)

full_name: Fin.insertNth_div_same
code: @[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) 
goal: i.insertNth x p / i.insertNth y p = Pi.mulSingle i (x / y)

full_name: Matrix.smul_empty
code: @[simp] lemma smul_empty (x : M) (v : Fin 0 → α) : x • v = ![] 
goal: x • v = ![]

full_name: Matrix.smul_cons
code: @[simp] lemma smul_cons (x : M) (y : α) (v : Fin n → α) :
    x • vecCons y v = vecCons (x • y) (x • v) 
goal: x • Matrix.vecCons y v = Matrix.vecCons (x • y) (x • v)

full_name: Matrix.empty_add_empty
code: @[simp] lemma empty_add_empty (v w : Fin 0 → α) : v + w = ![] 
goal: v + w = ![]

full_name: Matrix.cons_add
code: @[simp] lemma cons_add (x : α) (v : Fin n → α) (w : Fin n.succ → α) :
    vecCons x v + w = vecCons (x + vecHead w) (v + vecTail w) 
goal: Matrix.vecCons x v + w = Matrix.vecCons (x + Matrix.vecHead w) (v + Matrix.vecTail w)

full_name: Matrix.add_cons
code: @[simp] lemma add_cons (v : Fin n.succ → α) (y : α) (w : Fin n → α) :
    v + vecCons y w = vecCons (vecHead v + y) (vecTail v + w) 
goal: v + Matrix.vecCons y w = Matrix.vecCons (Matrix.vecHead v + y) (Matrix.vecTail v + w)

full_name: Matrix.cons_add_cons
code: lemma cons_add_cons (x : α) (v : Fin n → α) (y : α) (w : Fin n → α) :
    vecCons x v + vecCons y w = vecCons (x + y) (v + w) 
goal: Matrix.vecCons x v + Matrix.vecCons y w = Matrix.vecCons (x + y) (v + w)

full_name: Matrix.head_add
code: @[simp] lemma head_add (a b : Fin n.succ → α) : vecHead (a + b) = vecHead a + vecHead b 
goal: Matrix.vecHead (a + b) = Matrix.vecHead a + Matrix.vecHead b

full_name: Matrix.tail_add
code: @[simp] lemma tail_add (a b : Fin n.succ → α) : vecTail (a + b) = vecTail a + vecTail b 
goal: Matrix.vecTail (a + b) = Matrix.vecTail a + Matrix.vecTail b

full_name: Matrix.empty_sub_empty
code: @[simp] lemma empty_sub_empty (v w : Fin 0 → α) : v - w = ![] 
goal: v - w = ![]

full_name: Matrix.cons_sub
code: @[simp] lemma cons_sub (x : α) (v : Fin n → α) (w : Fin n.succ → α) :
    vecCons x v - w = vecCons (x - vecHead w) (v - vecTail w) 
goal: Matrix.vecCons x v - w = Matrix.vecCons (x - Matrix.vecHead w) (v - Matrix.vecTail w)

full_name: Matrix.sub_cons
code: @[simp] lemma sub_cons (v : Fin n.succ → α) (y : α) (w : Fin n → α) :
    v - vecCons y w = vecCons (vecHead v - y) (vecTail v - w) 
goal: v - Matrix.vecCons y w = Matrix.vecCons (Matrix.vecHead v - y) (Matrix.vecTail v - w)

full_name: Matrix.cons_sub_cons
code: lemma cons_sub_cons (x : α) (v : Fin n → α) (y : α) (w : Fin n → α) :
    vecCons x v - vecCons y w = vecCons (x - y) (v - w) 
goal: Matrix.vecCons x v - Matrix.vecCons y w = Matrix.vecCons (x - y) (v - w)

full_name: Matrix.head_sub
code: @[simp] lemma head_sub (a b : Fin n.succ → α) : vecHead (a - b) = vecHead a - vecHead b 
goal: Matrix.vecHead (a - b) = Matrix.vecHead a - Matrix.vecHead b

full_name: Matrix.tail_sub
code: @[simp] lemma tail_sub (a b : Fin n.succ → α) : vecTail (a - b) = vecTail a - vecTail b 
goal: Matrix.vecTail (a - b) = Matrix.vecTail a - Matrix.vecTail b

full_name: Matrix.zero_empty
code: @[simp] lemma zero_empty : (0 : Fin 0 → α) = ![] 
goal: 0 = ![]

full_name: Matrix.cons_zero_zero
code: @[simp] lemma cons_zero_zero : vecCons (0 : α) (0 : Fin n → α) = 0 
goal: Matrix.vecCons 0 0 = 0

full_name: Matrix.head_zero
code: @[simp] lemma head_zero : vecHead (0 : Fin n.succ → α) = 0 
goal: Matrix.vecHead 0 = 0

full_name: Matrix.tail_zero
code: @[simp] lemma tail_zero : vecTail (0 : Fin n.succ → α) = 0 
goal: Matrix.vecTail 0 = 0

full_name: Matrix.cons_eq_zero_iff
code: @[simp] lemma cons_eq_zero_iff {v : Fin n → α} {x : α} : vecCons x v = 0 ↔ x = 0 ∧ v = 0 
goal: Matrix.vecCons x v = 0 ↔ x = 0 ∧ v = 0

full_name: Matrix.cons_nonzero_iff
code: lemma cons_nonzero_iff {v : Fin n → α} {x : α} : vecCons x v ≠ 0 ↔ x ≠ 0 ∨ v ≠ 0 
goal: Matrix.vecCons x v ≠ 0 ↔ x ≠ 0 ∨ v ≠ 0

full_name: Matrix.neg_empty
code: @[simp] lemma neg_empty (v : Fin 0 → α) : -v = ![] 
goal: -v = ![]

full_name: Matrix.neg_cons
code: @[simp] lemma neg_cons (x : α) (v : Fin n → α) : -vecCons x v = vecCons (-x) (-v) 
goal: -Matrix.vecCons x v = Matrix.vecCons (-x) (-v)

full_name: Matrix.head_neg
code: @[simp] lemma head_neg (a : Fin n.succ → α) : vecHead (-a) = -vecHead a 
goal: Matrix.vecHead (-a) = -Matrix.vecHead a

full_name: Matrix.tail_neg
code: @[simp] lemma tail_neg (a : Fin n.succ → α) : vecTail (-a) = -vecTail a 
goal: Matrix.vecTail (-a) = -Matrix.vecTail a