File: Mathlib/LinearAlgebra/Matrix/DotProduct.lean

full_name: Matrix.dotProduct_stdBasis_eq_mul
code: @[simp]
theorem dotProduct_stdBasis_eq_mul [DecidableEq n] (v : n → R) (c : R) (i : n) :
    dotProduct v (LinearMap.stdBasis R (fun _ => R) i c) = v i * c 
goal: Matrix.dotProduct v ((LinearMap.stdBasis R (fun x => R) i) c) = v i * c

full_name: Matrix.dotProduct_stdBasis_one
code: theorem dotProduct_stdBasis_one [DecidableEq n] (v : n → R) (i : n) :
    dotProduct v (LinearMap.stdBasis R (fun _ => R) i 1) = v i 
goal: Matrix.dotProduct v ((LinearMap.stdBasis R (fun x => R) i) 1) = v i

full_name: Matrix.dotProduct_eq
code: theorem dotProduct_eq (v w : n → R) (h : ∀ u, dotProduct v u = dotProduct w u) : v = w 
goal: v = w

full_name: Matrix.dotProduct_eq_iff
code: theorem dotProduct_eq_iff {v w : n → R} : (∀ u, dotProduct v u = dotProduct w u) ↔ v = w 
goal: (∀ (u : n → R), Matrix.dotProduct v u = Matrix.dotProduct w u) ↔ v = w

full_name: Matrix.dotProduct_eq_zero
code: theorem dotProduct_eq_zero (v : n → R) (h : ∀ w, dotProduct v w = 0) : v = 0 
goal: v = 0

full_name: Matrix.dotProduct_eq_zero_iff
code: theorem dotProduct_eq_zero_iff {v : n → R} : (∀ w, dotProduct v w = 0) ↔ v = 0 
goal: (∀ (w : n → R), Matrix.dotProduct v w = 0) ↔ v = 0

full_name: Matrix.dotProduct_nonneg_of_nonneg
code: lemma dotProduct_nonneg_of_nonneg {v w : n → R} (hv : 0 ≤ v) (hw : 0 ≤ w) : 0 ≤ dotProduct v w 
goal: 0 ≤ Matrix.dotProduct v w

full_name: Matrix.dotProduct_le_dotProduct_of_nonneg_right
code: lemma dotProduct_le_dotProduct_of_nonneg_right {u v w : n → R} (huv : u ≤ v) (hw : 0 ≤ w) :
    dotProduct u w ≤ dotProduct v w 
goal: Matrix.dotProduct u w ≤ Matrix.dotProduct v w

full_name: Matrix.dotProduct_le_dotProduct_of_nonneg_left
code: lemma dotProduct_le_dotProduct_of_nonneg_left {u v w : n → R} (huv : u ≤ v) (hw : 0 ≤ w) :
    dotProduct w u ≤ dotProduct w v 
goal: Matrix.dotProduct w u ≤ Matrix.dotProduct w v

full_name: Matrix.dotProduct_self_eq_zero
code: @[simp]
theorem dotProduct_self_eq_zero [LinearOrderedRing R] {v : n → R} : dotProduct v v = 0 ↔ v = 0 
goal: Matrix.dotProduct v v = 0 ↔ v = 0

full_name: Matrix.dotProduct_star_self_eq_zero
code: /-- Note that this applies to `ℂ` via `Complex.strictOrderedCommRing`. -/
@[simp]
theorem dotProduct_star_self_eq_zero {v : n → R} : dotProduct (star v) v = 0 ↔ v = 0 
goal: Matrix.dotProduct (star v) v = 0 ↔ v = 0

full_name: Matrix.dotProduct_self_star_eq_zero
code: /-- Note that this applies to `ℂ` via `Complex.strictOrderedCommRing`. -/
@[simp]
theorem dotProduct_self_star_eq_zero {v : n → R} : dotProduct v (star v) = 0 ↔ v = 0 
goal: Matrix.dotProduct v (star v) = 0 ↔ v = 0

full_name: Matrix.conjTranspose_mul_self_eq_zero
code: @[simp]
lemma conjTranspose_mul_self_eq_zero {A : Matrix m n R} : Aᴴ * A = 0 ↔ A = 0 
goal: A.conjTranspose * A = 0 ↔ A = 0

full_name: Matrix.self_mul_conjTranspose_eq_zero
code: @[simp]
lemma self_mul_conjTranspose_eq_zero {A : Matrix m n R} : A * Aᴴ = 0 ↔ A = 0 
goal: A * A.conjTranspose = 0 ↔ A = 0

full_name: Matrix.conjTranspose_mul_self_mul_eq_zero
code: lemma conjTranspose_mul_self_mul_eq_zero (A : Matrix m n R) (B : Matrix n p R) :
    (Aᴴ * A) * B = 0 ↔ A * B = 0 
goal: A.conjTranspose * A * B = 0 ↔ A * B = 0

full_name: Matrix.self_mul_conjTranspose_mul_eq_zero
code: lemma self_mul_conjTranspose_mul_eq_zero (A : Matrix m n R) (B : Matrix m p R) :
    (A * Aᴴ) * B = 0 ↔ Aᴴ * B = 0 
goal: A * A.conjTranspose * B = 0 ↔ A.conjTranspose * B = 0

full_name: Matrix.mul_self_mul_conjTranspose_eq_zero
code: lemma mul_self_mul_conjTranspose_eq_zero (A : Matrix m n R) (B : Matrix p m R) :
    B * (A * Aᴴ) = 0 ↔ B * A = 0 
goal: B * (A * A.conjTranspose) = 0 ↔ B * A = 0

full_name: Matrix.mul_conjTranspose_mul_self_eq_zero
code: lemma mul_conjTranspose_mul_self_eq_zero (A : Matrix m n R) (B : Matrix p n R) :
    B * (Aᴴ * A) = 0 ↔ B * Aᴴ = 0 
goal: B * (A.conjTranspose * A) = 0 ↔ B * A.conjTranspose = 0

full_name: Matrix.conjTranspose_mul_self_mulVec_eq_zero
code: lemma conjTranspose_mul_self_mulVec_eq_zero (A : Matrix m n R) (v : n → R) :
    (Aᴴ * A) *ᵥ v = 0 ↔ A *ᵥ v = 0 
goal: (A.conjTranspose * A).mulVec v = 0 ↔ A.mulVec v = 0

full_name: Matrix.self_mul_conjTranspose_mulVec_eq_zero
code: lemma self_mul_conjTranspose_mulVec_eq_zero (A : Matrix m n R) (v : m → R) :
    (A * Aᴴ) *ᵥ v = 0 ↔ Aᴴ *ᵥ v = 0 
goal: (A * A.conjTranspose).mulVec v = 0 ↔ A.conjTranspose.mulVec v = 0

full_name: Matrix.vecMul_conjTranspose_mul_self_eq_zero
code: lemma vecMul_conjTranspose_mul_self_eq_zero (A : Matrix m n R) (v : n → R) :
    v ᵥ* (Aᴴ * A) = 0 ↔ v ᵥ* Aᴴ = 0 
goal: Matrix.vecMul v (A.conjTranspose * A) = 0 ↔ Matrix.vecMul v A.conjTranspose = 0

full_name: Matrix.vecMul_self_mul_conjTranspose_eq_zero
code: lemma vecMul_self_mul_conjTranspose_eq_zero (A : Matrix m n R) (v : m → R) :
    v ᵥ* (A * Aᴴ) = 0 ↔ v ᵥ* A = 0 
goal: Matrix.vecMul v (A * A.conjTranspose) = 0 ↔ Matrix.vecMul v A = 0