ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/LinearAlgebra/Matrix/Orthogonal.lean

full_name: Matrix.HasOrthogonalRows
code: /-- `A.HasOrthogonalRows` means matrix `A` has orthogonal rows (with respect to
`Matrix.dotProduct`). -/
def HasOrthogonalRows [Fintype n] : Prop 
goal: Prop

full_name: Matrix.HasOrthogonalCols
code: /-- `A.HasOrthogonalCols` means matrix `A` has orthogonal columns (with respect to
`Matrix.dotProduct`). -/
def HasOrthogonalCols [Fintype m] : Prop 
goal: Prop

full_name: Matrix.transpose_hasOrthogonalRows_iff_hasOrthogonalCols
code: /-- `Aᵀ` has orthogonal rows iff `A` has orthogonal columns. -/
@[simp]
theorem transpose_hasOrthogonalRows_iff_hasOrthogonalCols [Fintype m] :
    Aᵀ.HasOrthogonalRows ↔ A.HasOrthogonalCols 
goal: A.transpose.HasOrthogonalRows ↔ A.HasOrthogonalCols

full_name: Matrix.transpose_hasOrthogonalCols_iff_hasOrthogonalRows
code: /-- `Aᵀ` has orthogonal columns iff `A` has orthogonal rows. -/
@[simp]
theorem transpose_hasOrthogonalCols_iff_hasOrthogonalRows [Fintype n] :
    Aᵀ.HasOrthogonalCols ↔ A.HasOrthogonalRows 
goal: A.transpose.HasOrthogonalCols ↔ A.HasOrthogonalRows

full_name: Matrix.HasOrthogonalRows.hasOrthogonalCols
code: theorem HasOrthogonalRows.hasOrthogonalCols [Fintype m] (h : Aᵀ.HasOrthogonalRows) :
    A.HasOrthogonalCols 
goal: A.HasOrthogonalCols

full_name: Matrix.HasOrthogonalCols.transpose_hasOrthogonalRows
code: theorem HasOrthogonalCols.transpose_hasOrthogonalRows [Fintype m] (h : A.HasOrthogonalCols) :
    Aᵀ.HasOrthogonalRows 
goal: A.transpose.HasOrthogonalRows

full_name: Matrix.HasOrthogonalCols.hasOrthogonalRows
code: theorem HasOrthogonalCols.hasOrthogonalRows [Fintype n] (h : Aᵀ.HasOrthogonalCols) :
    A.HasOrthogonalRows 
goal: A.HasOrthogonalRows

full_name: Matrix.HasOrthogonalRows.transpose_hasOrthogonalCols
code: theorem HasOrthogonalRows.transpose_hasOrthogonalCols [Fintype n] (h : A.HasOrthogonalRows) :
    Aᵀ.HasOrthogonalCols 
goal: A.transpose.HasOrthogonalCols
File: Mathlib/LinearAlgebra/Matrix/Dual.lean

full_name: LinearMap.toMatrix_transpose
code: @[simp]
theorem LinearMap.toMatrix_transpose (u : V₁ →ₗ[K] V₂) :
    LinearMap.toMatrix B₂.dualBasis B₁.dualBasis (Module.Dual.transpose (R := K) u) =
      (LinearMap.toMatrix B₁ B₂ u)ᵀ 
goal: (LinearMap.toMatrix B₂.dualBasis B₁.dualBasis) (Module.Dual.transpose u) = ((LinearMap.toMatrix B₁ B₂) u)ᵀ

full_name: Matrix.toLin_transpose
code: @[simp]
theorem Matrix.toLin_transpose (M : Matrix ι₁ ι₂ K) : Matrix.toLin B₁.dualBasis B₂.dualBasis Mᵀ =
    Module.Dual.transpose (R := K) (Matrix.toLin B₂ B₁ M) 
goal: (Matrix.toLin B₁.dualBasis B₂.dualBasis) Mᵀ = Module.Dual.transpose ((Matrix.toLin B₂ B₁) M)
File: Mathlib/LinearAlgebra/Matrix/ProjectiveSpecialLinearGroup.lean

full_name: Matrix.ProjectiveSpecialLinearGroup
code: /-- A projective special linear group is the quotient of a special linear group by its center. -/
abbrev ProjectiveSpecialLinearGroup : Type _ 
goal: Type (max (max u v) v u)

full_name: MatrixGroups._aux_Mathlib_LinearAlgebra_Matrix_ProjectiveSpecialLinearGroup___unexpand_Matrix_ProjectiveSpecialLinearGroup_1
code: /-- `PSL(n, R)` is the projective special linear group `SL(n, R)/Z(SL(n, R))`. -/
scoped[MatrixGroups] notation "PSL(" n ", " R ")" => Matrix.ProjectiveSpecialLinearGroup (Fin n) R
goal: Lean.PrettyPrinter.Unexpander

full_name: MatrixGroups.«_aux_Mathlib_LinearAlgebra_Matrix_ProjectiveSpecialLinearGroup___macroRules_MatrixGroups_termPSL(_,_)_1»
code: /-- `PSL(n, R)` is the projective special linear group `SL(n, R)/Z(SL(n, R))`. -/
scoped[MatrixGroups] notation "PSL(" n ", " R ")" => Matrix.ProjectiveSpecialLinearGroup (Fin n) R
goal: Lean.Macro
File: Mathlib/LinearAlgebra/Matrix/LDL.lean

full_name: «_aux_Mathlib_LinearAlgebra_Matrix_LDL___macroRules_term⟪_,_⟫ₑ_1»
code: local notation "⟪" x ", " y "⟫ₑ" =>
  @inner 𝕜 _ _ ((WithLp.equiv 2 _).symm x) ((WithLp.equiv _ _).symm y)
goal: Lean.Macro

full_name: LDL.lowerInv
code: /-- The inverse of the lower triangular matrix `L` of the LDL-decomposition. It is obtained by
applying Gram-Schmidt-Orthogonalization w.r.t. the inner product induced by `Sᵀ` on the standard
basis vectors `Pi.basisFun`. -/
noncomputable def LDL.lowerInv : Matrix n n 𝕜 
goal: Matrix n n 𝕜

full_name: LDL.lowerInv_eq_gramSchmidtBasis
code: theorem LDL.lowerInv_eq_gramSchmidtBasis :
    LDL.lowerInv hS =
      ((Pi.basisFun 𝕜 n).toMatrix
          (@gramSchmidtBasis 𝕜 (n → 𝕜) _ (_ : _) (InnerProductSpace.ofMatrix hS.transpose) n _ _ _
            (Pi.basisFun 𝕜 n)))ᵀ 
goal: LDL.lowerInv hS = ((Pi.basisFun 𝕜 n).toMatrix ⇑(gramSchmidtBasis (Pi.basisFun 𝕜 n))).transpose

full_name: LDL.invertibleLowerInv
code: noncomputable instance LDL.invertibleLowerInv : Invertible (LDL.lowerInv hS) 
goal: Invertible (LDL.lowerInv hS)

full_name: LDL.lowerInv_orthogonal
code: theorem LDL.lowerInv_orthogonal {i j : n} (h₀ : i ≠ j) :
    ⟪LDL.lowerInv hS i, Sᵀ *ᵥ LDL.lowerInv hS j⟫ₑ = 0 
goal: ⟪(WithLp.equiv 2 (n → 𝕜)).symm (LDL.lowerInv hS i),
    (WithLp.equiv 2 (n → 𝕜)).symm (S.transpose.mulVec (LDL.lowerInv hS j))⟫_𝕜 =
  0

full_name: LDL.diagEntries
code: /-- The entries of the diagonal matrix `D` of the LDL decomposition. -/
noncomputable def LDL.diagEntries : n → 𝕜 
goal: n → 𝕜

full_name: LDL.diag
code: /-- The diagonal matrix `D` of the LDL decomposition. -/
noncomputable def LDL.diag : Matrix n n 𝕜 
goal: Matrix n n 𝕜

full_name: LDL.lowerInv_triangular
code: theorem LDL.lowerInv_triangular {i j : n} (hij : i < j) : LDL.lowerInv hS i j = 0 
goal: LDL.lowerInv hS i j = 0

full_name: LDL.diag_eq_lowerInv_conj
code: /-- Inverse statement of **LDL decomposition**: we can conjugate a positive definite matrix
by some lower triangular matrix and get a diagonal matrix. -/
theorem LDL.diag_eq_lowerInv_conj : LDL.diag hS = LDL.lowerInv hS * S * (LDL.lowerInv hS)ᴴ 
goal: LDL.diag hS = LDL.lowerInv hS * S * (LDL.lowerInv hS).conjTranspose

full_name: LDL.lower
code: /-- The lower triangular matrix `L` of the LDL decomposition. -/
noncomputable def LDL.lower 
goal: Matrix n n 𝕜

full_name: LDL.lower_conj_diag
code: /-- **LDL decomposition**: any positive definite matrix `S` can be
decomposed as `S = LDLᴴ` where `L` is a lower-triangular matrix and `D` is a diagonal matrix.  -/
theorem LDL.lower_conj_diag : LDL.lower hS * LDL.diag hS * (LDL.lower hS)ᴴ = S 
goal: LDL.lower hS * LDL.diag hS * (LDL.lower hS).conjTranspose = S
File: Mathlib/LinearAlgebra/Matrix/Polynomial.lean

full_name: Polynomial.natDegree_det_X_add_C_le
code: theorem natDegree_det_X_add_C_le (A B : Matrix n n α) :
    natDegree (det ((X : α[X]) • A.map C + B.map C : Matrix n n α[X])) ≤ Fintype.card n 
goal: (Polynomial.X • A.map ⇑Polynomial.C + B.map ⇑Polynomial.C).det.natDegree ≤ Fintype.card n

full_name: Polynomial.coeff_det_X_add_C_zero
code: theorem coeff_det_X_add_C_zero (A B : Matrix n n α) :
    coeff (det ((X : α[X]) • A.map C + B.map C)) 0 = det B 
goal: (Polynomial.X • A.map ⇑Polynomial.C + B.map ⇑Polynomial.C).det.coeff 0 = B.det

full_name: Polynomial.coeff_det_X_add_C_card
code: theorem coeff_det_X_add_C_card (A B : Matrix n n α) :
    coeff (det ((X : α[X]) • A.map C + B.map C)) (Fintype.card n) = det A 
goal: (Polynomial.X • A.map ⇑Polynomial.C + B.map ⇑Polynomial.C).det.coeff (Fintype.card n) = A.det

full_name: Polynomial.leadingCoeff_det_X_one_add_C
code: theorem leadingCoeff_det_X_one_add_C (A : Matrix n n α) :
    leadingCoeff (det ((X : α[X]) • (1 : Matrix n n α[X]) + A.map C)) = 1 
goal: (Polynomial.X • 1 + A.map ⇑Polynomial.C).det.leadingCoeff = 1
File: Mathlib/LinearAlgebra/Matrix/GeneralLinearGroup/Card.lean

full_name: _aux_Mathlib_LinearAlgebra_Matrix_GeneralLinearGroup_Card___macroRules_termQ_1
code: local notation "q" => Fintype.card K
goal: Lean.Macro

full_name: _aux_Mathlib_LinearAlgebra_Matrix_GeneralLinearGroup_Card___unexpand_Fintype_card_1
code: local notation "q" => Fintype.card K
goal: Lean.PrettyPrinter.Unexpander

full_name: _aux_Mathlib_LinearAlgebra_Matrix_GeneralLinearGroup_Card___macroRules_termN_1
code: local notation "n" => FiniteDimensional.finrank K V
goal: Lean.Macro

full_name: _aux_Mathlib_LinearAlgebra_Matrix_GeneralLinearGroup_Card___unexpand_FiniteDimensional_finrank_1
code: local notation "n" => FiniteDimensional.finrank K V
goal: Lean.PrettyPrinter.Unexpander

full_name: card_linearIndependent
code: /-- The cardinal of the set of linearly independent vectors over a finite dimensional vector space
over a finite field. -/
theorem card_linearIndependent {k : ℕ} (hk : k ≤ n) :
    Nat.card { s : Fin k → V // LinearIndependent K s } =
      ∏ i : Fin k, (q ^ n - q ^ i.val) 
goal: Nat.card { s // LinearIndependent K s } =
  ∏ i : Fin k, (Fintype.card K ^ FiniteDimensional.finrank K V - Fintype.card K ^ ↑i)

full_name: Matrix._aux_Mathlib_LinearAlgebra_Matrix_GeneralLinearGroup_Card___macroRules_Matrix_termQ_1
code: local notation "q" => Fintype.card 𝔽
goal: Lean.Macro

full_name: Matrix._aux_Mathlib_LinearAlgebra_Matrix_GeneralLinearGroup_Card___unexpand_Fintype_card_1
code: local notation "q" => Fintype.card 𝔽
goal: Lean.PrettyPrinter.Unexpander

full_name: Matrix.equiv_GL_linearindependent
code: /-- Equivalence between `GL n F` and `n` vectors of length `n` that are linearly independent. Given
by sending a matrix to its coloumns. -/
noncomputable def equiv_GL_linearindependent (hn : 0 < n) :
    GL (Fin n) 𝔽 ≃ { s : Fin n → Fin n → 𝔽 // LinearIndependent 𝔽 s } 
goal: GL (Fin n) 𝔽 ≃ { s // LinearIndependent 𝔽 s }

full_name: Matrix.card_GL_field
code: /-- The cardinal of the general linear group over a finite field. -/
theorem card_GL_field :
    Nat.card (GL (Fin n) 𝔽) = ∏ i : (Fin n), (q ^ n - q ^ ( i : ℕ )) 
goal: Nat.card (GL (Fin n) 𝔽) = ∏ i : Fin n, (Fintype.card 𝔽 ^ n - Fintype.card 𝔽 ^ ↑i)
File: Mathlib/LinearAlgebra/Matrix/MvPolynomial.lean

full_name: Matrix.mvPolynomialX
code: /-- The matrix with variable `X (i,j)` at location `(i,j)`. -/
noncomputable def mvPolynomialX [CommSemiring R] : Matrix m n (MvPolynomial (m × n) R) 
goal: Matrix m n (MvPolynomial (m × n) R)

full_name: Matrix.mvPolynomialX_apply
code: @[simp]
theorem mvPolynomialX_apply [CommSemiring R] (i j) :
    mvPolynomialX m n R i j = MvPolynomial.X (i, j) 
goal: Matrix.mvPolynomialX m n R i j = MvPolynomial.X (i, j)

full_name: Matrix.mvPolynomialX_map_eval₂
code: /-- Any matrix `A` can be expressed as the evaluation of `Matrix.mvPolynomialX`.

This is of particular use when `MvPolynomial (m × n) R` is an integral domain but `S` is
not, as if the `MvPolynomial.eval₂` can be pulled to the outside of a goal, it can be solved in
under cancellative assumptions. -/
theorem mvPolynomialX_map_eval₂ [CommSemiring R] [CommSemiring S] (f : R →+* S) (A : Matrix m n S) :
    (mvPolynomialX m n R).map (MvPolynomial.eval₂ f fun p : m × n => A p.1 p.2) = A 
goal: (Matrix.mvPolynomialX m n R).map (MvPolynomial.eval₂ f fun p => A p.1 p.2) = A

full_name: Matrix.mvPolynomialX_mapMatrix_eval
code: /-- A variant of `Matrix.mvPolynomialX_map_eval₂` with a bundled `RingHom` on the LHS. -/
theorem mvPolynomialX_mapMatrix_eval [Fintype m] [DecidableEq m] [CommSemiring R]
    (A : Matrix m m R) :
    (MvPolynomial.eval fun p : m × m => A p.1 p.2).mapMatrix (mvPolynomialX m m R) = A 
goal: (MvPolynomial.eval fun p => A p.1 p.2).mapMatrix (Matrix.mvPolynomialX m m R) = A

full_name: Matrix.mvPolynomialX_mapMatrix_aeval
code: /-- A variant of `Matrix.mvPolynomialX_map_eval₂` with a bundled `AlgHom` on the LHS. -/
theorem mvPolynomialX_mapMatrix_aeval [Fintype m] [DecidableEq m] [CommSemiring R] [CommSemiring S]
    [Algebra R S] (A : Matrix m m S) :
    (MvPolynomial.aeval fun p : m × m => A p.1 p.2).mapMatrix (mvPolynomialX m m R) = A 
goal: (MvPolynomial.aeval fun p => A p.1 p.2).mapMatrix (Matrix.mvPolynomialX m m R) = A

full_name: Matrix.det_mvPolynomialX_ne_zero
code: /-- In a nontrivial ring, `Matrix.mvPolynomialX m m R` has non-zero determinant. -/
theorem det_mvPolynomialX_ne_zero [DecidableEq m] [Fintype m] [CommRing R] [Nontrivial R] :
    det (mvPolynomialX m m R) ≠ 0 
goal: (Matrix.mvPolynomialX m m R).det ≠ 0
File: Mathlib/LinearAlgebra/Matrix/AbsoluteValue.lean

full_name: Matrix.det_le
code: theorem det_le {A : Matrix n n R} {abv : AbsoluteValue R S} {x : S} (hx : ∀ i j, abv (A i j) ≤ x) :
    abv A.det ≤ Nat.factorial (Fintype.card n) • x ^ Fintype.card n 
goal: abv A.det ≤ (Fintype.card n).factorial • x ^ Fintype.card n

full_name: Matrix.det_sum_le
code: theorem det_sum_le {ι : Type*} (s : Finset ι) {A : ι → Matrix n n R} {abv : AbsoluteValue R S}
    {x : S} (hx : ∀ k i j, abv (A k i j) ≤ x) :
    abv (det (∑ k ∈ s, A k)) ≤
      Nat.factorial (Fintype.card n) • (Finset.card s • x) ^ Fintype.card n 
goal: abv (∑ k ∈ s, A k).det ≤ (Fintype.card n).factorial • (s.card • x) ^ Fintype.card n

full_name: Matrix.det_sum_smul_le
code: theorem det_sum_smul_le {ι : Type*} (s : Finset ι) {c : ι → R} {A : ι → Matrix n n R}
    {abv : AbsoluteValue R S} {x : S} (hx : ∀ k i j, abv (A k i j) ≤ x) {y : S}
    (hy : ∀ k, abv (c k) ≤ y) :
    abv (det (∑ k ∈ s, c k • A k)) ≤
      Nat.factorial (Fintype.card n) • (Finset.card s • y * x) ^ Fintype.card n 
goal: abv (∑ k ∈ s, c k • A k).det ≤ (Fintype.card n).factorial • (s.card • y * x) ^ Fintype.card n
File: Mathlib/LinearAlgebra/Matrix/Permutation.lean

full_name: Equiv.Perm.permMatrix
code: /-- the permutation matrix associated with an `Equiv.Perm` -/
abbrev Equiv.Perm.permMatrix [Zero R] [One R] : Matrix n n R 
goal: Matrix n n R

full_name: Matrix.det_permutation
code: /-- The determinant of a permutation matrix equals its sign. -/
@[simp]
theorem det_permutation [CommRing R] : det (σ.permMatrix R) = Perm.sign σ 
goal: (Equiv.Perm.permMatrix R σ).det = ↑↑(Equiv.Perm.sign σ)

full_name: Matrix.trace_permutation
code: /-- The trace of a permutation matrix equals the number of fixed points. -/
theorem trace_permutation [AddCommMonoidWithOne R] :
    trace (σ.permMatrix R) = (Function.fixedPoints σ).ncard 
goal: (Equiv.Perm.permMatrix R σ).trace = ↑(Function.fixedPoints ⇑σ).ncard
File: Mathlib/LinearAlgebra/Matrix/Diagonal.lean

full_name: Matrix.proj_diagonal
code: theorem proj_diagonal (i : n) (w : n → R) : (proj i).comp (toLin' (diagonal w)) = w i • proj i 
goal: LinearMap.proj i ∘ₗ Matrix.toLin' (Matrix.diagonal w) = w i • LinearMap.proj i

full_name: Matrix.diagonal_comp_stdBasis
code: theorem diagonal_comp_stdBasis (w : n → R) (i : n) :
    (diagonal w).toLin'.comp (LinearMap.stdBasis R (fun _ : n => R) i) =
      w i • LinearMap.stdBasis R (fun _ : n => R) i 
goal: Matrix.toLin' (Matrix.diagonal w) ∘ₗ LinearMap.stdBasis R (fun x => R) i = w i • LinearMap.stdBasis R (fun x => R) i

full_name: Matrix.diagonal_toLin'
code: theorem diagonal_toLin' (w : n → R) :
    toLin' (diagonal w) = LinearMap.pi fun i => w i • LinearMap.proj i 
goal: Matrix.toLin' (Matrix.diagonal w) = LinearMap.pi fun i => w i • LinearMap.proj i

full_name: Matrix.ker_diagonal_toLin'
code: theorem ker_diagonal_toLin' [DecidableEq m] (w : m → K) :
    ker (toLin' (diagonal w)) =
      ⨆ i ∈ { i | w i = 0 }, LinearMap.range (LinearMap.stdBasis K (fun _ => K) i) 
goal: LinearMap.ker (Matrix.toLin' (Matrix.diagonal w)) =
  ⨆ i ∈ {i | w i = 0}, LinearMap.range (LinearMap.stdBasis K (fun x => K) i)

full_name: Matrix.range_diagonal
code: theorem range_diagonal [DecidableEq m] (w : m → K) :
    LinearMap.range (toLin' (diagonal w)) =
      ⨆ i ∈ { i | w i ≠ 0 }, LinearMap.range (LinearMap.stdBasis K (fun _ => K) i) 
goal: LinearMap.range (Matrix.toLin' (Matrix.diagonal w)) =
  ⨆ i ∈ {i | w i ≠ 0}, LinearMap.range (LinearMap.stdBasis K (fun x => K) i)

full_name: LinearMap.rank_diagonal
code: theorem rank_diagonal [DecidableEq m] [DecidableEq K] (w : m → K) :
    LinearMap.rank (toLin' (diagonal w)) = Fintype.card { i // w i ≠ 0 } 
goal: (Matrix.toLin' (Matrix.diagonal w)).rank = ↑(Fintype.card { i // w i ≠ 0 })
File: Mathlib/LinearAlgebra/Matrix/Determinant/Misc.lean

full_name: Matrix.submatrix_succAbove_det_eq_negOnePow_submatrix_succAbove_det
code: /-- Let `M` be a `(n+1) × n` matrix whose row sums to zero. Then all the matrices obtained by
deleting one row have the same determinant up to a sign. -/
theorem submatrix_succAbove_det_eq_negOnePow_submatrix_succAbove_det {n : ℕ}
    (M : Matrix (Fin (n + 1)) (Fin n) R) (hv : ∑ j, M j = 0) (j₁ j₂ : Fin (n + 1)) :
    (M.submatrix (Fin.succAbove j₁) id).det =
      Int.negOnePow (j₁ - j₂) • (M.submatrix (Fin.succAbove j₂) id).det 
goal: (M.submatrix j₁.succAbove id).det = (↑↑j₁ - ↑↑j₂).negOnePow • (M.submatrix j₂.succAbove id).det

full_name: Matrix.submatrix_succAbove_det_eq_negOnePow_submatrix_succAbove_det'
code: /-- Let `M` be a `(n+1) × n` matrix whose column sums to zero. Then all the matrices obtained by
deleting one column have the same determinant up to a sign. -/
theorem submatrix_succAbove_det_eq_negOnePow_submatrix_succAbove_det' {n : ℕ}
    (M : Matrix (Fin n) (Fin (n + 1)) R) (hv : ∀ i, ∑ j, M i j = 0) (j₁ j₂ : Fin (n + 1)) :
    (M.submatrix id (Fin.succAbove j₁)).det =
      Int.negOnePow (j₁ - j₂) • (M.submatrix id (Fin.succAbove j₂)).det 
goal: (M.submatrix id j₁.succAbove).det = (↑↑j₁ - ↑↑j₂).negOnePow • (M.submatrix id j₂.succAbove).det
File: Mathlib/LinearAlgebra/Matrix/HermitianFunctionalCalculus.lean

full_name: Matrix.finite_real_spectrum
code: lemma finite_real_spectrum : (spectrum ℝ A).Finite 
goal: (spectrum ℝ A).Finite

full_name: Matrix.instFiniteElemRealSpectrum
code: instance : Finite (spectrum ℝ A) 
goal: Finite ↑(spectrum ℝ A)

full_name: Matrix.IsHermitian.eigenvalues_eq_spectrum_real
code: /-- The `ℝ`-spectrum of a Hermitian matrix over `RCLike` field is the range of the eigenvalue
function -/
theorem eigenvalues_eq_spectrum_real {a : Matrix n n 𝕜} (ha : IsHermitian a) :
    spectrum ℝ a = Set.range (ha.eigenvalues) 
goal: spectrum ℝ a = Set.range ha.eigenvalues

full_name: Matrix.IsHermitian.cfcAux
code: /-- The star algebra homomorphism underlying the instance of the continuous functional
calculus of a Hermitian matrix. This is an auxiliary definition and is not intended
for use outside of this file. -/
@[simps]
noncomputable def cfcAux : C(spectrum ℝ A, ℝ) →⋆ₐ[ℝ] (Matrix n n 𝕜) 
goal: C(↑(spectrum ℝ A), ℝ) →⋆ₐ[ℝ] Matrix n n 𝕜

full_name: Matrix.IsHermitian.cfcAux_apply
code: /-- The star algebra homomorphism underlying the instance of the continuous functional
calculus of a Hermitian matrix. This is an auxiliary definition and is not intended
for use outside of this file. -/
@[simps]
noncomputable def cfcAux : C(spectrum ℝ A, ℝ) →⋆ₐ[ℝ] (Matrix n n 𝕜) 
goal: hA.cfcAux g =
  ↑hA.eigenvectorUnitary * Matrix.diagonal (RCLike.ofReal ∘ ⇑g ∘ fun i => ⟨hA.eigenvalues i, ⋯⟩) *
    star ↑hA.eigenvectorUnitary

full_name: Matrix.IsHermitian.closedEmbedding_cfcAux
code: lemma closedEmbedding_cfcAux : ClosedEmbedding hA.cfcAux 
goal: ClosedEmbedding ⇑hA.cfcAux

full_name: Matrix.IsHermitian.cfcAux_id
code: lemma cfcAux_id : hA.cfcAux (.restrict (spectrum ℝ A) (.id ℝ)) = A 
goal: hA.cfcAux (ContinuousMap.restrict (spectrum ℝ A) (ContinuousMap.id ℝ)) = A

full_name: Matrix.IsHermitian.instContinuousFunctionalCalculus
code: /-- Instance of the continuous functional calculus for a Hermitian matrix over `𝕜` with
`RCLike 𝕜`. -/
instance instContinuousFunctionalCalculus :
    ContinuousFunctionalCalculus ℝ (IsSelfAdjoint : Matrix n n 𝕜 → Prop) 
goal: ContinuousFunctionalCalculus ℝ IsSelfAdjoint

full_name: Matrix.IsHermitian.instUniqueContinuousFunctionalCalculus
code: instance instUniqueContinuousFunctionalCalculus :
    UniqueContinuousFunctionalCalculus ℝ (Matrix n n 𝕜) 
goal: UniqueContinuousFunctionalCalculus ℝ (Matrix n n 𝕜)

full_name: Matrix.IsHermitian.cfc
code: /-- The continuous functional calculus of a Hermitian matrix as a triple product using the
spectral theorem. Note that this actually operates on bare functions since every function is
continuous on the spectrum of a matrix, since the spectrum is finite. This is shown to be equal to
the generic continuous functional calculus API in `Matrix.IsHermitian.cfc_eq`. In general, users
should prefer the generic API, especially because it will make rewriting easier. -/
protected noncomputable def cfc (f : ℝ → ℝ) : Matrix n n 𝕜 
goal: Matrix n n 𝕜

full_name: Matrix.IsHermitian.cfc_eq
code: lemma cfc_eq (f : ℝ → ℝ) : cfc f A = hA.cfc f 
goal: cfc f A = hA.cfc f
File: Mathlib/LinearAlgebra/Dimension/LinearMap.lean

full_name: LinearMap.rank
code: /-- `rank f` is the rank of a `LinearMap` `f`, defined as the dimension of `f.range`. -/
abbrev rank (f : V →ₗ[K] V') : Cardinal 
goal: Cardinal.{v'}

full_name: LinearMap.rank_le_range
code: theorem rank_le_range (f : V →ₗ[K] V') : rank f ≤ Module.rank K V' 
goal: f.rank ≤ Module.rank K V'

full_name: LinearMap.rank_le_domain
code: theorem rank_le_domain (f : V →ₗ[K] V₁) : rank f ≤ Module.rank K V 
goal: f.rank ≤ Module.rank K V

full_name: LinearMap.rank_zero
code: @[simp]
theorem rank_zero [Nontrivial K] : rank (0 : V →ₗ[K] V') = 0 
goal: LinearMap.rank 0 = 0

full_name: LinearMap.rank_comp_le_left
code: theorem rank_comp_le_left (g : V →ₗ[K] V') (f : V' →ₗ[K] V'') : rank (f.comp g) ≤ rank f 
goal: (f ∘ₗ g).rank ≤ f.rank

full_name: LinearMap.lift_rank_comp_le_right
code: theorem lift_rank_comp_le_right (g : V →ₗ[K] V') (f : V' →ₗ[K] V'') :
    Cardinal.lift.{v'} (rank (f.comp g)) ≤ Cardinal.lift.{v''} (rank g) 
goal: Cardinal.lift.{v', v''} (f ∘ₗ g).rank ≤ Cardinal.lift.{v'', v'} g.rank

full_name: LinearMap.lift_rank_comp_le
code: /-- The rank of the composition of two maps is less than the minimum of their ranks. -/
theorem lift_rank_comp_le (g : V →ₗ[K] V') (f : V' →ₗ[K] V'') :
    Cardinal.lift.{v'} (rank (f.comp g)) ≤
      min (Cardinal.lift.{v'} (rank f)) (Cardinal.lift.{v''} (rank g)) 
goal: Cardinal.lift.{v', v''} (f ∘ₗ g).rank ≤ min (Cardinal.lift.{v', v''} f.rank) (Cardinal.lift.{v'', v'} g.rank)

full_name: LinearMap.rank_comp_le_right
code: theorem rank_comp_le_right (g : V →ₗ[K] V') (f : V' →ₗ[K] V'₁) : rank (f.comp g) ≤ rank g 
goal: (f ∘ₗ g).rank ≤ g.rank

full_name: LinearMap.rank_comp_le
code: /-- The rank of the composition of two maps is less than the minimum of their ranks.

See `lift_rank_comp_le` for the universe-polymorphic version. -/
theorem rank_comp_le (g : V →ₗ[K] V') (f : V' →ₗ[K] V'₁) :
    rank (f.comp g) ≤ min (rank f) (rank g) 
goal: (f ∘ₗ g).rank ≤ min f.rank g.rank

full_name: LinearMap.rank_add_le
code: theorem rank_add_le (f g : V →ₗ[K] V') : rank (f + g) ≤ rank f + rank g 
goal: (f + g).rank ≤ f.rank + g.rank

full_name: LinearMap.rank_finset_sum_le
code: theorem rank_finset_sum_le {η} (s : Finset η) (f : η → V →ₗ[K] V') :
    rank (∑ d ∈ s, f d) ≤ ∑ d ∈ s, rank (f d) 
goal: (∑ d ∈ s, f d).rank ≤ ∑ d ∈ s, (f d).rank

full_name: LinearMap.le_rank_iff_exists_linearIndependent
code: theorem le_rank_iff_exists_linearIndependent {c : Cardinal} {f : V →ₗ[K] V'} :
    c ≤ rank f ↔ ∃ s : Set V,
    Cardinal.lift.{v'} #s = Cardinal.lift.{v} c ∧ LinearIndependent K (fun x : s => f x) 
goal: c ≤ f.rank ↔ ∃ s, Cardinal.lift.{v', v} #↑s = Cardinal.lift.{v, v'} c ∧ LinearIndependent K fun (x : ↑s) => f ↑x

full_name: LinearMap.le_rank_iff_exists_linearIndependent_finset
code: theorem le_rank_iff_exists_linearIndependent_finset {n : ℕ} {f : V →ₗ[K] V'} :
    ↑n ≤ rank f ↔ ∃ s : Finset V, s.card = n ∧ LinearIndependent K fun x : (s : Set V) => f x 
goal: ↑n ≤ f.rank ↔ ∃ s, s.card = n ∧ LinearIndependent K fun (x : ↑↑s) => f ↑x