File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

full_name: Matrix.toBilin'Aux
code: /-- The map from `Matrix n n R` to bilinear forms on `n → R`.

This is an auxiliary definition for the equivalence `Matrix.toBilin'`. -/
def Matrix.toBilin'Aux [Fintype n] (M : Matrix n n R₂) : BilinForm R₂ (n → R₂) 
goal: LinearMap.BilinForm R₂ (n → R₂)

full_name: Matrix.toBilin'Aux_stdBasis
code: theorem Matrix.toBilin'Aux_stdBasis [Fintype n] [DecidableEq n] (M : Matrix n n R₂) (i j : n) :
    M.toBilin'Aux (LinearMap.stdBasis R₂ (fun _ => R₂) i 1)
      (LinearMap.stdBasis R₂ (fun _ => R₂) j 1) = M i j 
goal: (M.toBilin'Aux ((LinearMap.stdBasis R₂ (fun x => R₂) i) 1)) ((LinearMap.stdBasis R₂ (fun x => R₂) j) 1) = M i j

full_name: BilinForm.toMatrixAux
code: /-- The linear map from bilinear forms to `Matrix n n R` given an `n`-indexed basis.

This is an auxiliary definition for the equivalence `Matrix.toBilin'`. -/
def BilinForm.toMatrixAux (b : n → M₂) : BilinForm R₂ M₂ →ₗ[R₂] Matrix n n R₂ 
goal: LinearMap.BilinForm R₂ M₂ →ₗ[R₂] Matrix n n R₂

full_name: LinearMap.BilinForm.toMatrixAux_apply
code: @[simp]
theorem LinearMap.BilinForm.toMatrixAux_apply (B : BilinForm R₂ M₂) (b : n → M₂) (i j : n) :
    -- Porting note: had to hint the base ring even though it should be clear from context...
    BilinForm.toMatrixAux (R₂ := R₂) b B i j = B (b i) (b j) 
goal: (BilinForm.toMatrixAux b) B i j = (B (b i)) (b j)

full_name: toBilin'Aux_toMatrixAux
code: theorem toBilin'Aux_toMatrixAux [DecidableEq n] (B₂ : BilinForm R₂ (n → R₂)) :
    -- Porting note: had to hint the base ring even though it should be clear from context...
    Matrix.toBilin'Aux (BilinForm.toMatrixAux (R₂ := R₂)
      (fun j => stdBasis R₂ (fun _ => R₂) j 1) B₂) = B₂ 
goal: ((BilinForm.toMatrixAux fun j => (LinearMap.stdBasis R₂ (fun x => R₂) j) 1) B₂).toBilin'Aux = B₂

full_name: LinearMap.BilinForm.toMatrix'
code: /-- The linear equivalence between bilinear forms on `n → R` and `n × n` matrices -/
def LinearMap.BilinForm.toMatrix' : BilinForm R₂ (n → R₂) ≃ₗ[R₂] Matrix n n R₂ 
goal: LinearMap.BilinForm R₂ (n → R₂) ≃ₗ[R₂] Matrix n n R₂

full_name: LinearMap.BilinForm.toMatrixAux_stdBasis
code: @[simp]
theorem LinearMap.BilinForm.toMatrixAux_stdBasis (B : BilinForm R₂ (n → R₂)) :
    -- Porting note: had to hint the base ring even though it should be clear from context...
    BilinForm.toMatrixAux (R₂ := R₂) (fun j => stdBasis R₂ (fun _ => R₂) j 1) B =
      BilinForm.toMatrix' B 
goal: (BilinForm.toMatrixAux fun j => (LinearMap.stdBasis R₂ (fun x => R₂) j) 1) B = LinearMap.BilinForm.toMatrix' B

full_name: Matrix.toBilin'
code: /-- The linear equivalence between `n × n` matrices and bilinear forms on `n → R` -/
def Matrix.toBilin' : Matrix n n R₂ ≃ₗ[R₂] BilinForm R₂ (n → R₂) 
goal: Matrix n n R₂ ≃ₗ[R₂] LinearMap.BilinForm R₂ (n → R₂)

full_name: Matrix.toBilin'Aux_eq
code: @[simp]
theorem Matrix.toBilin'Aux_eq (M : Matrix n n R₂) : Matrix.toBilin'Aux M = Matrix.toBilin' M 
goal: M.toBilin'Aux = Matrix.toBilin' M

full_name: Matrix.toBilin'_apply
code: theorem Matrix.toBilin'_apply (M : Matrix n n R₂) (x y : n → R₂) :
    Matrix.toBilin' M x y = ∑ i, ∑ j, x i * M i j * y j 
goal: ((Matrix.toBilin' M) x) y = ∑ i : n, ∑ j : n, x i * M i j * y j

full_name: Matrix.toBilin'_apply'
code: theorem Matrix.toBilin'_apply' (M : Matrix n n R₂) (v w : n → R₂) :
    Matrix.toBilin' M v w = Matrix.dotProduct v (M *ᵥ w) 
goal: ((Matrix.toBilin' M) v) w = Matrix.dotProduct v (M.mulVec w)

full_name: Matrix.toBilin'_stdBasis
code: @[simp]
theorem Matrix.toBilin'_stdBasis (M : Matrix n n R₂) (i j : n) :
    Matrix.toBilin' M
      (LinearMap.stdBasis R₂ (fun _ => R₂) i 1)
      (LinearMap.stdBasis R₂ (fun _ => R₂) j 1) = M i j 
goal: ((Matrix.toBilin' M) ((LinearMap.stdBasis R₂ (fun x => R₂) i) 1)) ((LinearMap.stdBasis R₂ (fun x => R₂) j) 1) = M i j

full_name: LinearMap.BilinForm.toMatrix'_symm
code: @[simp]
theorem LinearMap.BilinForm.toMatrix'_symm :
    (BilinForm.toMatrix'.symm : Matrix n n R₂ ≃ₗ[R₂] _) = Matrix.toBilin' 
goal: LinearMap.BilinForm.toMatrix'.symm = Matrix.toBilin'

full_name: Matrix.toBilin'_symm
code: @[simp]
theorem Matrix.toBilin'_symm :
    (Matrix.toBilin'.symm : _ ≃ₗ[R₂] Matrix n n R₂) = BilinForm.toMatrix' 
goal: Matrix.toBilin'.symm = LinearMap.BilinForm.toMatrix'

full_name: Matrix.toBilin'_toMatrix'
code: @[simp]
theorem Matrix.toBilin'_toMatrix' (B : BilinForm R₂ (n → R₂)) :
    Matrix.toBilin' (BilinForm.toMatrix' B) = B 
goal: Matrix.toBilin' (LinearMap.BilinForm.toMatrix' B) = B

full_name: LinearMap.BilinForm.toMatrix'_toBilin'
code: @[simp]
theorem BilinForm.toMatrix'_toBilin' (M : Matrix n n R₂) :
    BilinForm.toMatrix' (Matrix.toBilin' M) = M 
goal: LinearMap.BilinForm.toMatrix' (Matrix.toBilin' M) = M

full_name: LinearMap.BilinForm.toMatrix'_apply
code: @[simp]
theorem BilinForm.toMatrix'_apply (B : BilinForm R₂ (n → R₂)) (i j : n) :
    BilinForm.toMatrix' B i j = B (stdBasis R₂ (fun _ => R₂) i 1) (stdBasis R₂ (fun _ => R₂) j 1) 
goal: LinearMap.BilinForm.toMatrix' B i j =
  (B ((LinearMap.stdBasis R₂ (fun x => R₂) i) 1)) ((LinearMap.stdBasis R₂ (fun x => R₂) j) 1)

full_name: LinearMap.BilinForm.toMatrix'_comp
code: @[simp]
theorem BilinForm.toMatrix'_comp (B : BilinForm R₂ (n → R₂)) (l r : (o → R₂) →ₗ[R₂] n → R₂) :
    BilinForm.toMatrix' (B.comp l r) =
      (LinearMap.toMatrix' l)ᵀ * BilinForm.toMatrix' B * LinearMap.toMatrix' r 
goal: LinearMap.BilinForm.toMatrix' (B.comp l r) =
  (LinearMap.toMatrix' l).transpose * LinearMap.BilinForm.toMatrix' B * LinearMap.toMatrix' r

full_name: LinearMap.BilinForm.toMatrix'_compLeft
code: theorem BilinForm.toMatrix'_compLeft (B : BilinForm R₂ (n → R₂)) (f : (n → R₂) →ₗ[R₂] n → R₂) :
    BilinForm.toMatrix' (B.compLeft f) = (LinearMap.toMatrix' f)ᵀ * BilinForm.toMatrix' B 
goal: LinearMap.BilinForm.toMatrix' (B.compLeft f) = (LinearMap.toMatrix' f).transpose * LinearMap.BilinForm.toMatrix' B

full_name: LinearMap.BilinForm.toMatrix'_compRight
code: theorem BilinForm.toMatrix'_compRight (B : BilinForm R₂ (n → R₂)) (f : (n → R₂) →ₗ[R₂] n → R₂) :
    BilinForm.toMatrix' (B.compRight f) = BilinForm.toMatrix' B * LinearMap.toMatrix' f 
goal: LinearMap.BilinForm.toMatrix' (B.compRight f) = LinearMap.BilinForm.toMatrix' B * LinearMap.toMatrix' f

full_name: LinearMap.BilinForm.mul_toMatrix'_mul
code: theorem BilinForm.mul_toMatrix'_mul (B : BilinForm R₂ (n → R₂)) (M : Matrix o n R₂)
    (N : Matrix n o R₂) : M * BilinForm.toMatrix' B * N =
      BilinForm.toMatrix' (B.comp (Matrix.toLin' Mᵀ) (Matrix.toLin' N)) 
goal: M * LinearMap.BilinForm.toMatrix' B * N =
  LinearMap.BilinForm.toMatrix' (B.comp (Matrix.toLin' M.transpose) (Matrix.toLin' N))

full_name: LinearMap.BilinForm.mul_toMatrix'
code: theorem BilinForm.mul_toMatrix' (B : BilinForm R₂ (n → R₂)) (M : Matrix n n R₂) :
    M * BilinForm.toMatrix' B = BilinForm.toMatrix' (B.compLeft (Matrix.toLin' Mᵀ)) 
goal: M * LinearMap.BilinForm.toMatrix' B = LinearMap.BilinForm.toMatrix' (B.compLeft (Matrix.toLin' M.transpose))

full_name: LinearMap.BilinForm.toMatrix'_mul
code: theorem BilinForm.toMatrix'_mul (B : BilinForm R₂ (n → R₂)) (M : Matrix n n R₂) :
    BilinForm.toMatrix' B * M = BilinForm.toMatrix' (B.compRight (Matrix.toLin' M)) 
goal: LinearMap.BilinForm.toMatrix' B * M = LinearMap.BilinForm.toMatrix' (B.compRight (Matrix.toLin' M))

full_name: Matrix.toBilin'_comp
code: theorem Matrix.toBilin'_comp (M : Matrix n n R₂) (P Q : Matrix n o R₂) :
    M.toBilin'.comp (Matrix.toLin' P) (Matrix.toLin' Q) = Matrix.toBilin' (Pᵀ * M * Q) 
goal: (Matrix.toBilin' M).comp (Matrix.toLin' P) (Matrix.toLin' Q) = Matrix.toBilin' (P.transpose * M * Q)

full_name: BilinForm.toMatrix
code: /-- `BilinForm.toMatrix b` is the equivalence between `R`-bilinear forms on `M` and
`n`-by-`n` matrices with entries in `R`, if `b` is an `R`-basis for `M`. -/
noncomputable def BilinForm.toMatrix : BilinForm R₂ M₂ ≃ₗ[R₂] Matrix n n R₂ 
goal: LinearMap.BilinForm R₂ M₂ ≃ₗ[R₂] Matrix n n R₂

full_name: Matrix.toBilin
code: /-- `BilinForm.toMatrix b` is the equivalence between `R`-bilinear forms on `M` and
`n`-by-`n` matrices with entries in `R`, if `b` is an `R`-basis for `M`. -/
noncomputable def Matrix.toBilin : Matrix n n R₂ ≃ₗ[R₂] BilinForm R₂ M₂ 
goal: Matrix n n R₂ ≃ₗ[R₂] LinearMap.BilinForm R₂ M₂

full_name: BilinForm.toMatrix_apply
code: @[simp]
theorem BilinForm.toMatrix_apply (B : BilinForm R₂ M₂) (i j : n) :
    BilinForm.toMatrix b B i j = B (b i) (b j) 
goal: (BilinForm.toMatrix b) B i j = (B (b i)) (b j)

full_name: Matrix.toBilin_apply
code: @[simp]
theorem Matrix.toBilin_apply (M : Matrix n n R₂) (x y : M₂) :
    Matrix.toBilin b M x y = ∑ i, ∑ j, b.repr x i * M i j * b.repr y j 
goal: (((Matrix.toBilin b) M) x) y = ∑ i : n, ∑ j : n, (b.repr x) i * M i j * (b.repr y) j

full_name: BilinearForm.toMatrixAux_eq
code: theorem BilinearForm.toMatrixAux_eq (B : BilinForm R₂ M₂) :
    BilinForm.toMatrixAux (R₂ := R₂) b B = BilinForm.toMatrix b B 
goal: (BilinForm.toMatrixAux ⇑b) B = (BilinForm.toMatrix b) B

full_name: BilinForm.toMatrix_symm
code: @[simp]
theorem BilinForm.toMatrix_symm : (BilinForm.toMatrix b).symm = Matrix.toBilin b 
goal: (BilinForm.toMatrix b).symm = Matrix.toBilin b

full_name: Matrix.toBilin_symm
code: @[simp]
theorem Matrix.toBilin_symm : (Matrix.toBilin b).symm = BilinForm.toMatrix b 
goal: (Matrix.toBilin b).symm = BilinForm.toMatrix b

full_name: Matrix.toBilin_basisFun
code: theorem Matrix.toBilin_basisFun : Matrix.toBilin (Pi.basisFun R₂ n) = Matrix.toBilin' 
goal: Matrix.toBilin (Pi.basisFun R₂ n) = Matrix.toBilin'

full_name: BilinForm.toMatrix_basisFun
code: theorem BilinForm.toMatrix_basisFun :
    BilinForm.toMatrix (Pi.basisFun R₂ n) = BilinForm.toMatrix' 
goal: BilinForm.toMatrix (Pi.basisFun R₂ n) = LinearMap.BilinForm.toMatrix'

full_name: Matrix.toBilin_toMatrix
code: @[simp]
theorem Matrix.toBilin_toMatrix (B : BilinForm R₂ M₂) :
    Matrix.toBilin b (BilinForm.toMatrix b B) = B 
goal: (Matrix.toBilin b) ((BilinForm.toMatrix b) B) = B

full_name: BilinForm.toMatrix_toBilin
code: @[simp]
theorem BilinForm.toMatrix_toBilin (M : Matrix n n R₂) :
    BilinForm.toMatrix b (Matrix.toBilin b M) = M 
goal: (BilinForm.toMatrix b) ((Matrix.toBilin b) M) = M

full_name: BilinForm.toMatrix_comp
code: theorem BilinForm.toMatrix_comp (B : BilinForm R₂ M₂) (l r : M₂' →ₗ[R₂] M₂) :
    BilinForm.toMatrix c (B.comp l r) =
      (LinearMap.toMatrix c b l)ᵀ * BilinForm.toMatrix b B * LinearMap.toMatrix c b r 
goal: (BilinForm.toMatrix c) (B.comp l r) =
  ((LinearMap.toMatrix c b) l).transpose * (BilinForm.toMatrix b) B * (LinearMap.toMatrix c b) r

full_name: BilinForm.toMatrix_compLeft
code: theorem BilinForm.toMatrix_compLeft (B : BilinForm R₂ M₂) (f : M₂ →ₗ[R₂] M₂) :
    BilinForm.toMatrix b (B.compLeft f) = (LinearMap.toMatrix b b f)ᵀ * BilinForm.toMatrix b B 
goal: (BilinForm.toMatrix b) (B.compLeft f) = ((LinearMap.toMatrix b b) f).transpose * (BilinForm.toMatrix b) B

full_name: BilinForm.toMatrix_compRight
code: theorem BilinForm.toMatrix_compRight (B : BilinForm R₂ M₂) (f : M₂ →ₗ[R₂] M₂) :
    BilinForm.toMatrix b (B.compRight f) = BilinForm.toMatrix b B * LinearMap.toMatrix b b f 
goal: (BilinForm.toMatrix b) (B.compRight f) = (BilinForm.toMatrix b) B * (LinearMap.toMatrix b b) f

full_name: BilinForm.toMatrix_mul_basis_toMatrix
code: @[simp]
theorem BilinForm.toMatrix_mul_basis_toMatrix (c : Basis o R₂ M₂) (B : BilinForm R₂ M₂) :
    (b.toMatrix c)ᵀ * BilinForm.toMatrix b B * b.toMatrix c = BilinForm.toMatrix c B 
goal: (b.toMatrix ⇑c).transpose * (BilinForm.toMatrix b) B * b.toMatrix ⇑c = (BilinForm.toMatrix c) B

full_name: BilinForm.mul_toMatrix_mul
code: theorem BilinForm.mul_toMatrix_mul (B : BilinForm R₂ M₂) (M : Matrix o n R₂) (N : Matrix n o R₂) :
    M * BilinForm.toMatrix b B * N =
      BilinForm.toMatrix c (B.comp (Matrix.toLin c b Mᵀ) (Matrix.toLin c b N)) 
goal: M * (BilinForm.toMatrix b) B * N =
  (BilinForm.toMatrix c) (B.comp ((Matrix.toLin c b) M.transpose) ((Matrix.toLin c b) N))

full_name: BilinForm.mul_toMatrix
code: theorem BilinForm.mul_toMatrix (B : BilinForm R₂ M₂) (M : Matrix n n R₂) :
    M * BilinForm.toMatrix b B = BilinForm.toMatrix b (B.compLeft (Matrix.toLin b b Mᵀ)) 
goal: M * (BilinForm.toMatrix b) B = (BilinForm.toMatrix b) (B.compLeft ((Matrix.toLin b b) M.transpose))

full_name: BilinForm.toMatrix_mul
code: theorem BilinForm.toMatrix_mul (B : BilinForm R₂ M₂) (M : Matrix n n R₂) :
    BilinForm.toMatrix b B * M = BilinForm.toMatrix b (B.compRight (Matrix.toLin b b M)) 
goal: (BilinForm.toMatrix b) B * M = (BilinForm.toMatrix b) (B.compRight ((Matrix.toLin b b) M))

full_name: Matrix.toBilin_comp
code: theorem Matrix.toBilin_comp (M : Matrix n n R₂) (P Q : Matrix n o R₂) :
    (Matrix.toBilin b M).comp (toLin c b P) (toLin c b Q) = Matrix.toBilin c (Pᵀ * M * Q) 
goal: ((Matrix.toBilin b) M).comp ((Matrix.toLin c b) P) ((Matrix.toLin c b) Q) = (Matrix.toBilin c) (P.transpose * M * Q)

full_name: isAdjointPair_toBilin'
code: @[simp]
theorem isAdjointPair_toBilin' [DecidableEq n] :
    BilinForm.IsAdjointPair (Matrix.toBilin' J) (Matrix.toBilin' J₃) (Matrix.toLin' A)
        (Matrix.toLin' A') ↔
      Matrix.IsAdjointPair J J₃ A A' 
goal: (Matrix.toBilin' J).IsAdjointPair (Matrix.toBilin' J₃) (Matrix.toLin' A) (Matrix.toLin' A') ↔ J.IsAdjointPair J₃ A A'

full_name: isAdjointPair_toBilin
code: @[simp]
theorem isAdjointPair_toBilin [DecidableEq n] :
    BilinForm.IsAdjointPair (Matrix.toBilin b J) (Matrix.toBilin b J₃) (Matrix.toLin b b A)
        (Matrix.toLin b b A') ↔
      Matrix.IsAdjointPair J J₃ A A' 
goal: ((Matrix.toBilin b) J).IsAdjointPair ((Matrix.toBilin b) J₃) ((Matrix.toLin b b) A) ((Matrix.toLin b b) A') ↔
  J.IsAdjointPair J₃ A A'

full_name: Matrix.isAdjointPair_equiv'
code: theorem Matrix.isAdjointPair_equiv' [DecidableEq n] (P : Matrix n n R₃) (h : IsUnit P) :
    (Pᵀ * J * P).IsAdjointPair (Pᵀ * J * P) A A' ↔
      J.IsAdjointPair J (P * A * P⁻¹) (P * A' * P⁻¹) 
goal: (P.transpose * J * P).IsAdjointPair (P.transpose * J * P) A A' ↔ J.IsAdjointPair J (P * A * P⁻¹) (P * A' * P⁻¹)

full_name: pairSelfAdjointMatricesSubmodule'
code: /-- The submodule of pair-self-adjoint matrices with respect to bilinear forms corresponding to
given matrices `J`, `J₂`. -/
def pairSelfAdjointMatricesSubmodule' : Submodule R₃ (Matrix n n R₃) 
goal: Submodule R₃ (Matrix n n R₃)

full_name: mem_pairSelfAdjointMatricesSubmodule'
code: theorem mem_pairSelfAdjointMatricesSubmodule' :
    A ∈ pairSelfAdjointMatricesSubmodule J J₃ ↔ Matrix.IsAdjointPair J J₃ A A 
goal: A ∈ pairSelfAdjointMatricesSubmodule J J₃ ↔ J.IsAdjointPair J₃ A A

full_name: selfAdjointMatricesSubmodule'
code: /-- The submodule of self-adjoint matrices with respect to the bilinear form corresponding to
the matrix `J`. -/
def selfAdjointMatricesSubmodule' : Submodule R₃ (Matrix n n R₃) 
goal: Submodule R₃ (Matrix n n R₃)

full_name: mem_selfAdjointMatricesSubmodule'
code: theorem mem_selfAdjointMatricesSubmodule' :
    A ∈ selfAdjointMatricesSubmodule J ↔ J.IsSelfAdjoint A 
goal: A ∈ selfAdjointMatricesSubmodule J ↔ J.IsSelfAdjoint A

full_name: skewAdjointMatricesSubmodule'
code: /-- The submodule of skew-adjoint matrices with respect to the bilinear form corresponding to
the matrix `J`. -/
def skewAdjointMatricesSubmodule' : Submodule R₃ (Matrix n n R₃) 
goal: Submodule R₃ (Matrix n n R₃)

full_name: mem_skewAdjointMatricesSubmodule'
code: theorem mem_skewAdjointMatricesSubmodule' :
    A ∈ skewAdjointMatricesSubmodule J ↔ J.IsSkewAdjoint A 
goal: A ∈ skewAdjointMatricesSubmodule J ↔ J.IsSkewAdjoint A

full_name: Matrix.nondegenerate_toBilin'_iff_nondegenerate_toBilin
code: theorem _root_.Matrix.nondegenerate_toBilin'_iff_nondegenerate_toBilin {M : Matrix ι ι R₂}
    (b : Basis ι R₂ M₂) : M.toBilin'.Nondegenerate ↔ (Matrix.toBilin b M).Nondegenerate 
goal: (Matrix.toBilin' M).Nondegenerate ↔ ((Matrix.toBilin b) M).Nondegenerate

full_name: Matrix.Nondegenerate.toBilin'
code: theorem _root_.Matrix.Nondegenerate.toBilin' {M : Matrix ι ι R₃} (h : M.Nondegenerate) :
    M.toBilin'.Nondegenerate 
goal: (Matrix.toBilin' M).Nondegenerate

full_name: Matrix.nondegenerate_toBilin'_iff
code: @[simp]
theorem _root_.Matrix.nondegenerate_toBilin'_iff {M : Matrix ι ι R₃} :
    M.toBilin'.Nondegenerate ↔ M.Nondegenerate 
goal: (Matrix.toBilin' M).Nondegenerate ↔ M.Nondegenerate

full_name: Matrix.Nondegenerate.toBilin
code: theorem _root_.Matrix.Nondegenerate.toBilin {M : Matrix ι ι R₃} (h : M.Nondegenerate)
    (b : Basis ι R₃ M₃) : (Matrix.toBilin b M).Nondegenerate 
goal: ((Matrix.toBilin b) M).Nondegenerate

full_name: Matrix.nondegenerate_toBilin_iff
code: @[simp]
theorem _root_.Matrix.nondegenerate_toBilin_iff {M : Matrix ι ι R₃} (b : Basis ι R₃ M₃) :
    (Matrix.toBilin b M).Nondegenerate ↔ M.Nondegenerate 
goal: ((Matrix.toBilin b) M).Nondegenerate ↔ M.Nondegenerate

full_name: LinearMap.BilinForm.nondegenerate_toMatrix'_iff
code: @[simp]
theorem nondegenerate_toMatrix'_iff {B : BilinForm R₃ (ι → R₃)} :
    B.toMatrix'.Nondegenerate (m := ι) ↔ B.Nondegenerate 
goal: (LinearMap.BilinForm.toMatrix' B).Nondegenerate ↔ B.Nondegenerate

full_name: LinearMap.BilinForm.Nondegenerate.toMatrix'
code: theorem Nondegenerate.toMatrix' {B : BilinForm R₃ (ι → R₃)} (h : B.Nondegenerate) :
    B.toMatrix'.Nondegenerate 
goal: (LinearMap.BilinForm.toMatrix' B).Nondegenerate

full_name: LinearMap.BilinForm.nondegenerate_toMatrix_iff
code: @[simp]
theorem nondegenerate_toMatrix_iff {B : BilinForm R₃ M₃} (b : Basis ι R₃ M₃) :
    (BilinForm.toMatrix b B).Nondegenerate ↔ B.Nondegenerate 
goal: ((BilinForm.toMatrix b) B).Nondegenerate ↔ B.Nondegenerate

full_name: LinearMap.BilinForm.Nondegenerate.toMatrix
code: theorem Nondegenerate.toMatrix {B : BilinForm R₃ M₃} (h : B.Nondegenerate) (b : Basis ι R₃ M₃) :
    (BilinForm.toMatrix b B).Nondegenerate 
goal: ((BilinForm.toMatrix b) B).Nondegenerate

full_name: LinearMap.BilinForm.nondegenerate_toBilin'_iff_det_ne_zero
code: theorem nondegenerate_toBilin'_iff_det_ne_zero {M : Matrix ι ι A} :
    M.toBilin'.Nondegenerate ↔ M.det ≠ 0 
goal: (Matrix.toBilin' M).Nondegenerate ↔ M.det ≠ 0

full_name: LinearMap.BilinForm.nondegenerate_toBilin'_of_det_ne_zero'
code: theorem nondegenerate_toBilin'_of_det_ne_zero' (M : Matrix ι ι A) (h : M.det ≠ 0) :
    M.toBilin'.Nondegenerate 
goal: (Matrix.toBilin' M).Nondegenerate

full_name: LinearMap.BilinForm.nondegenerate_iff_det_ne_zero
code: theorem nondegenerate_iff_det_ne_zero {B : BilinForm A M₃} (b : Basis ι A M₃) :
    B.Nondegenerate ↔ (BilinForm.toMatrix b B).det ≠ 0 
goal: B.Nondegenerate ↔ ((BilinForm.toMatrix b) B).det ≠ 0

full_name: LinearMap.BilinForm.nondegenerate_of_det_ne_zero
code: theorem nondegenerate_of_det_ne_zero (b : Basis ι A M₃) (h : (BilinForm.toMatrix b B₃).det ≠ 0) :
    B₃.Nondegenerate 
goal: B₃.Nondegenerate