# mathlibdocumentation

data.matrix.notation

# Matrix and vector notation

This file defines notation for vectors and matrices. Given a b c d : α, the notation allows us to write ![a, b, c, d] : fin 4 → α. Nesting vectors gives a matrix, so ![![a, b], ![c, d]] : matrix (fin 2) (fin 2) α. This file includes simp lemmas for applying operations in data.matrix.basic to values built out of this notation.

## Main definitions

• vec_empty is the empty vector (or 0 by n matrix) ![]
• vec_cons prepends an entry to a vector, so ![a, b] is vec_cons a (vec_cons b vec_empty)

## Implementation notes

The simp lemmas require that one of the arguments is of the form vec_cons _ _. This ensures simp works with entries only when (some) entries are already given. In other words, this notation will only appear in the output of simp if it already appears in the input.

## Notations

The main new notation is ![a, b], which gets expanded to vec_cons a (vec_cons b vec_empty).

def matrix.vec_empty {α : Type u} :
fin 0 → α

![] is the vector with no entries.

Equations
def matrix.vec_cons {α : Type u} {n : } :
α → (fin n → α)fin n.succ → α

vec_cons h t prepends an entry h to a vector t.

The inverse functions are vec_head and vec_tail. The notation ![a, b, ...] expands to vec_cons a (vec_cons b ...).

Equations
• = t
def matrix.vec_head {α : Type u} {n : } :
(fin n.succ → α) → α

vec_head v gives the first entry of the vector v

Equations
• = v 0
def matrix.vec_tail {α : Type u} {n : } :
(fin n.succ → α)fin n → α

vec_tail v gives a vector consisting of all entries of v except the first

Equations
theorem matrix.empty_eq {α : Type u} (v : fin 0 → α) :

@[simp]
theorem matrix.cons_val_zero {α : Type u} {m : } (x : α) (u : fin m → α) :
0 = x

theorem matrix.cons_val_zero' {α : Type u} {m : } (h : 0 < m.succ) (x : α) (u : fin m → α) :
0, h⟩ = x

@[simp]
theorem matrix.cons_val_succ {α : Type u} {m : } (x : α) (u : fin m → α) (i : fin m) :
i.succ = u i

@[simp]
theorem matrix.cons_val_succ' {α : Type u} {m i : } (h : i.succ < m.succ) (x : α) (u : fin m → α) :
i.succ, h⟩ = u i, _⟩

@[simp]
theorem matrix.head_cons {α : Type u} {m : } (x : α) (u : fin m → α) :
= x

@[simp]
theorem matrix.tail_cons {α : Type u} {m : } (x : α) (u : fin m → α) :
= u

@[simp]
theorem matrix.empty_val' {α : Type u} {n' : Type u_1} (j : n') :
(λ (i : fin 0), j) = matrix.vec_empty

@[simp]
theorem matrix.cons_val' {α : Type u} {m : } {n' : Type u_2} [fintype n'] (v : n' → α) (B : matrix (fin m) n' α) (i : fin m.succ) (j : n') :
i j = matrix.vec_cons (v j) (λ (i : fin m), B i j) i

@[simp]
theorem matrix.head_val' {α : Type u} {m : } {n' : Type u_2} [fintype n'] (B : matrix (fin m.succ) n' α) (j : n') :
matrix.vec_head (λ (i : fin m.succ), B i j) =

@[simp]
theorem matrix.tail_val' {α : Type u} {m : } {n' : Type u_2} [fintype n'] (B : matrix (fin m.succ) n' α) (j : n') :
matrix.vec_tail (λ (i : fin m.succ), B i j) = λ (i : fin m), j

@[simp]
theorem matrix.cons_head_tail {α : Type u} {m : } (u : fin m.succ → α) :

@[simp]
theorem matrix.range_cons {α : Type u} {n : } (x : α) (u : fin n → α) :
set.range u) = {x}

@[simp]
theorem matrix.range_empty {α : Type u} (u : fin 0 → α) :

@[simp]
theorem matrix.cons_val_one {α : Type u} {m : } (x : α) (u : fin m.succ → α) :
1 =

![a, b, ...] 1 is equal to b.

The simplifier needs a special lemma for length ≥ 2, in addition to cons_val_succ, because 1 : fin 1 = 0 : fin 1.

@[simp]
theorem matrix.cons_val_fin_one {α : Type u} (x : α) (u : fin 0 → α) (i : fin 1) :
i = x

### Numeral (bit0 and bit1) indices The following definitions and simp lemmas are to allow any numeral-indexed element of a vector given with matrix notation to be extracted by simp (even when the numeral is larger than the number of elements in the vector, which is taken modulo that number of elements by virtue of the semantics of bit0 and bit1 and of addition on fin n).

@[simp]
theorem matrix.empty_append {α : Type u} {n : } (v : fin n → α) :

@[simp]
theorem matrix.cons_append {α : Type u} {m n o : } (ho : o + 1 = m + 1 + n) (x : α) (u : fin m → α) (v : fin n → α) :
u) v = u v)

def matrix.vec_alt0 {α : Type u} {m n : } :
m = n + n(fin m → α)fin n → α

vec_alt0 v gives a vector with half the length of v, with only alternate elements (even-numbered).

Equations
def matrix.vec_alt1 {α : Type u} {m n : } :
m = n + n(fin m → α)fin n → α

vec_alt1 v gives a vector with half the length of v, with only alternate elements (odd-numbered).

Equations
theorem matrix.vec_alt0_append {α : Type u} {n : } (v : fin n → α) :
v) =

theorem matrix.vec_alt1_append {α : Type u} {n : } (v : fin (n + 1) → α) :
v) =

@[simp]
theorem matrix.cons_vec_bit0_eq_alt0 {α : Type u} {n : } (x : α) (u : fin n → α) (i : fin (n + 1)) :
(bit0 i) = u) u)) i

@[simp]
theorem matrix.cons_vec_bit1_eq_alt1 {α : Type u} {n : } (x : α) (u : fin n → α) (i : fin (n + 1)) :
(bit1 i) = u) u)) i

@[simp]
theorem matrix.cons_vec_alt0 {α : Type u} {m n : } (h : m + 1 + 1 = n + 1 + (n + 1)) (x y : α) (u : fin m → α) :
u)) = u)

@[simp]
theorem matrix.empty_vec_alt0 (α : Type u_1) {h : 0 = 0 + 0} :

@[simp]
theorem matrix.cons_vec_alt1 {α : Type u} {m n : } (h : m + 1 + 1 = n + 1 + (n + 1)) (x y : α) (u : fin m → α) :
u)) = u)

@[simp]
theorem matrix.empty_vec_alt1 (α : Type u_1) {h : 0 = 0 + 0} :

@[simp]
theorem matrix.dot_product_empty {α : Type u} [has_mul α] (v w : fin 0 → α) :
= 0

@[simp]
theorem matrix.cons_dot_product {α : Type u} {n : } [has_mul α] (x : α) (v : fin n → α) (w : fin n.succ → α) :
=

@[simp]
theorem matrix.dot_product_cons {α : Type u} {n : } [has_mul α] (v : fin n.succ → α) (x : α) (w : fin n → α) :
= * x +

@[simp]
theorem matrix.col_empty {α : Type u} (v : fin 0 → α) :

@[simp]
theorem matrix.col_cons {α : Type u} {m : } (x : α) (u : fin m → α) :
= matrix.vec_cons (λ (_x : unit), x) (matrix.col u)

@[simp]
theorem matrix.row_empty {α : Type u} :
= λ (_x : unit), matrix.vec_empty

@[simp]
theorem matrix.row_cons {α : Type u} {m : } (x : α) (u : fin m → α) :
= λ (_x : unit),

@[simp]
theorem matrix.transpose_empty_rows {α : Type u} {m' : Type u_1} [fintype m'] (A : matrix m' (fin 0) α) :

@[simp]
theorem matrix.transpose_empty_cols {α : Type u} {m' : Type u_1} [fintype m'] :

@[simp]
theorem matrix.cons_transpose {α : Type u} {m : } {n' : Type u_2} [fintype n'] (v : n' → α) (A : matrix (fin m) n' α) :
A) = λ (i : n'), matrix.vec_cons (v i) (A i)

@[simp]
theorem matrix.head_transpose {α : Type u} {n : } {m' : Type u_1} [fintype m'] (A : matrix m' (fin n.succ) α) :

@[simp]
theorem matrix.tail_transpose {α : Type u} {n : } {m' : Type u_1} [fintype m'] (A : matrix m' (fin n.succ) α) :

@[simp]
theorem matrix.empty_mul {α : Type u} {n' : Type u_2} {o' : Type u_3} [fintype n'] [fintype o'] [semiring α] (A : matrix (fin 0) n' α) (B : matrix n' o' α) :

@[simp]
theorem matrix.empty_mul_empty {α : Type u} {m' : Type u_1} {o' : Type u_3} [fintype m'] [fintype o'] [semiring α] (A : matrix m' (fin 0) α) (B : matrix (fin 0) o' α) :
A B = 0

@[simp]
theorem matrix.mul_empty {α : Type u} {m' : Type u_1} {n' : Type u_2} [fintype m'] [fintype n'] [semiring α] (A : matrix m' n' α) (B : matrix n' (fin 0) α) :
A B = λ (_x : m'), matrix.vec_empty

theorem matrix.mul_val_succ {α : Type u} {m : } {n' : Type u_2} {o' : Type u_3} [fintype n'] [fintype o'] [semiring α] (A : matrix (fin m.succ) n' α) (B : matrix n' o' α) (i : fin m) (j : o') :
(A B) i.succ j = B) i j

@[simp]
theorem matrix.cons_mul {α : Type u} {m : } {n' : Type u_2} {o' : Type u_3} [fintype n'] [fintype o'] [semiring α] (v : n' → α) (A : matrix (fin m) n' α) (B : matrix n' o' α) :
B = (A B)

@[simp]
theorem matrix.empty_vec_mul {α : Type u} {o' : Type u_3} [fintype o'] [semiring α] (v : fin 0 → α) (B : matrix (fin 0) o' α) :
= 0

@[simp]
theorem matrix.vec_mul_empty {α : Type u} {n' : Type u_2} [fintype n'] [semiring α] (v : n' → α) (B : matrix n' (fin 0) α) :

@[simp]
theorem matrix.cons_vec_mul {α : Type u} {n : } {o' : Type u_3} [fintype o'] [semiring α] (x : α) (v : fin n → α) (B : matrix (fin n.succ) o' α) :
B = +

@[simp]
theorem matrix.vec_mul_cons {α : Type u} {n : } {o' : Type u_3} [fintype o'] [semiring α] (v : fin n.succ → α) (w : o' → α) (B : matrix (fin n) o' α) :
B) = +

@[simp]
theorem matrix.empty_mul_vec {α : Type u} {n' : Type u_2} [fintype n'] [semiring α] (A : matrix (fin 0) n' α) (v : n' → α) :

@[simp]
theorem matrix.mul_vec_empty {α : Type u} {m' : Type u_1} [fintype m'] [semiring α] (A : matrix m' (fin 0) α) (v : fin 0 → α) :
A.mul_vec v = 0

@[simp]
theorem matrix.cons_mul_vec {α : Type u} {m : } {n' : Type u_2} [fintype n'] [semiring α] (v : n' → α) (A : fin mn' → α) (w : n' → α) :
w = w)

@[simp]
theorem matrix.mul_vec_cons {n : } {m' : Type u_1} [fintype m'] {α : Type u_2} (A : m' → fin n.succ → α) (x : α) (v : fin n → α) :
v) = +

@[simp]
theorem matrix.empty_vec_mul_vec {α : Type u} {n' : Type u_2} [fintype n'] [semiring α] (v : fin 0 → α) (w : n' → α) :

@[simp]
theorem matrix.vec_mul_vec_empty {α : Type u} {m' : Type u_1} [fintype m'] [semiring α] (v : m' → α) (w : fin 0 → α) :
= λ (_x : m'), matrix.vec_empty

@[simp]
theorem matrix.cons_vec_mul_vec {α : Type u} {m : } {n' : Type u_2} [fintype n'] [semiring α] (x : α) (v : fin m → α) (w : n' → α) :

@[simp]
theorem matrix.vec_mul_vec_cons {α : Type u} {n : } {m' : Type u_1} [fintype m'] [semiring α] (v : m' → α) (x : α) (w : fin n → α) :
= λ (i : m'), v i

@[simp]
theorem matrix.smul_empty {α : Type u} [semiring α] (x : α) (v : fin 0 → α) :

@[simp]
theorem matrix.smul_mat_empty {α : Type u} [semiring α] {m' : Type u_1} (x : α) (A : fin 0m' → α) :

@[simp]
theorem matrix.smul_cons {α : Type u} {n : } [semiring α] (x y : α) (v : fin n → α) :
x = matrix.vec_cons (x * y) (x v)

@[simp]
theorem matrix.smul_mat_cons {α : Type u} {m : } {n' : Type u_2} [fintype n'] [semiring α] (x : α) (v : n' → α) (A : matrix (fin m) n' α) :
x = matrix.vec_cons (x v) (x A)

@[simp]
theorem matrix.empty_add_empty {α : Type u} [has_add α] (v w : fin 0 → α) :

@[simp]
theorem matrix.cons_add {α : Type u} {n : } [has_add α] (x : α) (v : fin n → α) (w : fin n.succ → α) :
+ w = (v +

@[simp]
theorem matrix.add_cons {α : Type u} {n : } [has_add α] (v : fin n.succ → α) (y : α) (w : fin n → α) :
v + = + w)

@[simp]
theorem matrix.zero_empty {α : Type u} [has_zero α] :

@[simp]
theorem matrix.cons_zero_zero {α : Type u} {n : } [has_zero α] :
= 0

@[simp]
theorem matrix.head_zero {α : Type u} {n : } [has_zero α] :

@[simp]
theorem matrix.tail_zero {α : Type u} {n : } [has_zero α] :

@[simp]
theorem matrix.cons_eq_zero_iff {α : Type u} {n : } [has_zero α] {v : fin n → α} {x : α} :
= 0 x = 0 v = 0

theorem matrix.cons_nonzero_iff {α : Type u} {n : } [has_zero α] {v : fin n → α} {x : α} :
0 x 0 v 0

@[simp]
theorem matrix.neg_empty {α : Type u} [has_neg α] (v : fin 0 → α) :

@[simp]
theorem matrix.neg_cons {α : Type u} {n : } [has_neg α] (x : α) (v : fin n → α) :
- = (-v)

@[simp]
theorem matrix.minor_empty {α : Type u} {m' : Type u_1} {n' : Type u_2} {o' : Type u_3} [fintype m'] [fintype n'] [fintype o'] (A : matrix m' n' α) (row : fin 0 → m') (col : o' → n') :

@[simp]
theorem matrix.minor_cons_row {α : Type u} {m : } {m' : Type u_1} {n' : Type u_2} {o' : Type u_3} [fintype m'] [fintype n'] [fintype o'] (A : matrix m' n' α) (i : m') (row : fin m → m') (col : o' → n') :
A.minor row) col = matrix.vec_cons (λ (j : o'), A i (col j)) (A.minor row col)