File: Mathlib/Algebra/Lie/Rank.lean

full_name: LieModule._aux_Mathlib_Algebra_Lie_Rank___macroRules_LieModule_termφ_1
code: local notation "φ" => LieHom.toLinearMap (LieModule.toEnd R L M)
goal: Lean.Macro

full_name: LieModule._aux_Mathlib_Algebra_Lie_Rank___unexpand_LieHom_toLinearMap_1
code: local notation "φ" => LieHom.toLinearMap (LieModule.toEnd R L M)
goal: Lean.PrettyPrinter.Unexpander

full_name: LieModule.rank
code: /--
Let `M` be a representation of a Lie algebra `L` over a nontrivial commutative ring `R`,
and assume that `L` and `M` are finite free as `R`-module.
Then the coefficients of the characteristic polynomial of `⁅x, ·⁆` are polynomial in `x`.
The *rank* of `M` is the smallest `n` for which the `n`-th coefficient is not the zero polynomial.
-/
noncomputable
def rank : ℕ 
goal: ℕ

full_name: LieModule.polyCharpoly_coeff_rank_ne_zero
code: lemma polyCharpoly_coeff_rank_ne_zero :
    (polyCharpoly φ b).coeff (rank R L M) ≠ 0 
goal: ((↑(LieModule.toEnd R L M)).polyCharpoly b).coeff (LieModule.rank R L M) ≠ 0

full_name: LieModule.rank_eq_natTrailingDegree
code: lemma rank_eq_natTrailingDegree :
    rank R L M = (polyCharpoly φ b).natTrailingDegree 
goal: LieModule.rank R L M = ((↑(LieModule.toEnd R L M)).polyCharpoly b).natTrailingDegree

full_name: LieModule.rank_le_card
code: lemma rank_le_card : rank R L M ≤ Fintype.card ιₘ 
goal: LieModule.rank R L M ≤ Fintype.card ιₘ

full_name: LieModule.rank_le_finrank
code: lemma rank_le_finrank : rank R L M ≤ finrank R M 
goal: LieModule.rank R L M ≤ FiniteDimensional.finrank R M

full_name: LieModule.rank_le_natTrailingDegree_charpoly_ad
code: lemma rank_le_natTrailingDegree_charpoly_ad :
    rank R L M ≤ (toEnd R L M x).charpoly.natTrailingDegree 
goal: LieModule.rank R L M ≤ (LinearMap.charpoly ((LieModule.toEnd R L M) x)).natTrailingDegree

full_name: LieModule.IsRegular
code: /-- Let `x` be an element of a Lie algebra `L` over `R`, and write `n` for `rank R L`.
Then `x` is *regular*
if the `n`-th coefficient of the characteristic polynomial of `ad R L x` is non-zero. -/
def IsRegular (x : L) : Prop 
goal: Prop

full_name: LieModule.isRegular_def
code: lemma isRegular_def :
    IsRegular R M x ↔ (toEnd R L M x).charpoly.coeff (rank R L M) ≠ 0 
goal: LieModule.IsRegular R M x ↔ (LinearMap.charpoly ((LieModule.toEnd R L M) x)).coeff (LieModule.rank R L M) ≠ 0

full_name: LieModule.isRegular_iff_coeff_polyCharpoly_rank_ne_zero
code: lemma isRegular_iff_coeff_polyCharpoly_rank_ne_zero :
    IsRegular R M x ↔
    MvPolynomial.eval (b.repr x)
      ((polyCharpoly φ b).coeff (rank R L M)) ≠ 0 
goal: LieModule.IsRegular R M x ↔
  (MvPolynomial.eval ⇑(b.repr x)) (((↑(LieModule.toEnd R L M)).polyCharpoly b).coeff (LieModule.rank R L M)) ≠ 0

full_name: LieModule.isRegular_iff_natTrailingDegree_charpoly_eq_rank
code: lemma isRegular_iff_natTrailingDegree_charpoly_eq_rank :
    IsRegular R M x ↔ (toEnd R L M x).charpoly.natTrailingDegree = rank R L M 
goal: LieModule.IsRegular R M x ↔ (LinearMap.charpoly ((LieModule.toEnd R L M) x)).natTrailingDegree = LieModule.rank R L M

full_name: LieModule.exists_isRegular_of_finrank_le_card
code: lemma exists_isRegular_of_finrank_le_card (h : finrank R M ≤ #R) :
    ∃ x : L, IsRegular R M x 
goal: ∃ x, LieModule.IsRegular R M x

full_name: LieModule.exists_isRegular
code: lemma exists_isRegular [Infinite R] : ∃ x : L, IsRegular R M x 
goal: ∃ x, LieModule.IsRegular R M x

full_name: LieAlgebra.rank
code: /--
Let `L` be a Lie algebra over a nontrivial commutative ring `R`,
and assume that `L` is finite free as `R`-module.
Then the coefficients of the characteristic polynomial of `ad R L x` are polynomial in `x`.
The *rank* of `L` is the smallest `n` for which the `n`-th coefficient is not the zero polynomial.
-/
noncomputable
abbrev rank : ℕ 
goal: ℕ

full_name: LieAlgebra.polyCharpoly_coeff_rank_ne_zero
code: lemma polyCharpoly_coeff_rank_ne_zero :
    (polyCharpoly (ad R L).toLinearMap b).coeff (rank R L) ≠ 0 
goal: ((↑(LieAlgebra.ad R L)).polyCharpoly b).coeff (LieAlgebra.rank R L) ≠ 0

full_name: LieAlgebra.rank_eq_natTrailingDegree
code: lemma rank_eq_natTrailingDegree :
    rank R L = (polyCharpoly (ad R L).toLinearMap b).natTrailingDegree 
goal: LieAlgebra.rank R L = ((↑(LieAlgebra.ad R L)).polyCharpoly b).natTrailingDegree

full_name: LieAlgebra.rank_le_card
code: lemma rank_le_card : rank R L ≤ Fintype.card ι 
goal: LieAlgebra.rank R L ≤ Fintype.card ι

full_name: LieAlgebra.rank_le_finrank
code: lemma rank_le_finrank : rank R L ≤ finrank R L 
goal: LieAlgebra.rank R L ≤ FiniteDimensional.finrank R L

full_name: LieAlgebra.rank_le_natTrailingDegree_charpoly_ad
code: lemma rank_le_natTrailingDegree_charpoly_ad :
    rank R L ≤ (ad R L x).charpoly.natTrailingDegree 
goal: LieAlgebra.rank R L ≤ (LinearMap.charpoly ((LieAlgebra.ad R L) x)).natTrailingDegree

full_name: LieAlgebra.IsRegular
code: /-- Let `x` be an element of a Lie algebra `L` over `R`, and write `n` for `rank R L`.
Then `x` is *regular*
if the `n`-th coefficient of the characteristic polynomial of `ad R L x` is non-zero. -/
abbrev IsRegular (x : L) : Prop 
goal: Prop

full_name: LieAlgebra.isRegular_def
code: lemma isRegular_def :
    IsRegular R x ↔ (Polynomial.coeff (ad R L x).charpoly (rank R L) ≠ 0) 
goal: LieAlgebra.IsRegular R x ↔ (LinearMap.charpoly ((LieAlgebra.ad R L) x)).coeff (LieAlgebra.rank R L) ≠ 0

full_name: LieAlgebra.isRegular_iff_coeff_polyCharpoly_rank_ne_zero
code: lemma isRegular_iff_coeff_polyCharpoly_rank_ne_zero :
    IsRegular R x ↔
    MvPolynomial.eval (b.repr x)
      ((polyCharpoly (ad R L).toLinearMap b).coeff (rank R L)) ≠ 0 
goal: LieAlgebra.IsRegular R x ↔
  (MvPolynomial.eval ⇑(b.repr x)) (((↑(LieAlgebra.ad R L)).polyCharpoly b).coeff (LieAlgebra.rank R L)) ≠ 0

full_name: LieAlgebra.isRegular_iff_natTrailingDegree_charpoly_eq_rank
code: lemma isRegular_iff_natTrailingDegree_charpoly_eq_rank :
    IsRegular R x ↔ (ad R L x).charpoly.natTrailingDegree = rank R L 
goal: LieAlgebra.IsRegular R x ↔ (LinearMap.charpoly ((LieAlgebra.ad R L) x)).natTrailingDegree = LieAlgebra.rank R L

full_name: LieAlgebra.exists_isRegular_of_finrank_le_card
code: lemma exists_isRegular_of_finrank_le_card (h : finrank R L ≤ #R) :
    ∃ x : L, IsRegular R x 
goal: ∃ x, LieAlgebra.IsRegular R x

full_name: LieAlgebra.exists_isRegular
code: lemma exists_isRegular [Infinite R] : ∃ x : L, IsRegular R x 
goal: ∃ x, LieAlgebra.IsRegular R x

full_name: LieAlgebra.finrank_engel
code: lemma finrank_engel (x : L) :
    finrank K (engel K x) = (ad K L x).charpoly.natTrailingDegree 
goal: FiniteDimensional.finrank K ↥(LieSubalgebra.engel K x) = (LinearMap.charpoly ((LieAlgebra.ad K L) x)).natTrailingDegree

full_name: LieAlgebra.rank_le_finrank_engel
code: lemma rank_le_finrank_engel (x : L) :
    rank K L ≤ finrank K (engel K x) 
goal: LieAlgebra.rank K L ≤ FiniteDimensional.finrank K ↥(LieSubalgebra.engel K x)

full_name: LieAlgebra.isRegular_iff_finrank_engel_eq_rank
code: lemma isRegular_iff_finrank_engel_eq_rank (x : L) :
    IsRegular K x ↔ finrank K (engel K x) = rank K L 
goal: LieAlgebra.IsRegular K x ↔ FiniteDimensional.finrank K ↥(LieSubalgebra.engel K x) = LieAlgebra.rank K L