File: Mathlib/Algebra/Lie/OfAssociative.lean

full_name: LieRing.ofAssociativeRing
code: /-- An associative ring gives rise to a Lie ring by taking the bracket to be the ring commutator. -/
instance (priority := 100) ofAssociativeRing : LieRing A 
goal: LieRing A

full_name: LieRing.of_associative_ring_bracket
code: theorem of_associative_ring_bracket (x y : A) : ⁅x, y⁆ = x * y - y * x 
goal: ⁅x, y⁆ = x * y - y * x

full_name: LieRing.lie_apply
code: @[simp]
theorem lie_apply {α : Type*} (f g : α → A) (a : α) : ⁅f, g⁆ a = ⁅f a, g a⁆ 
goal: ⁅f, g⁆ a = ⁅f a, g a⁆

full_name: LieRingModule.ofAssociativeModule
code: /-- We can regard a module over an associative ring `A` as a Lie ring module over `A` with Lie
bracket equal to its ring commutator.

Note that this cannot be a global instance because it would create a diamond when `M = A`,
specifically we can build two mathematically-different `bracket A A`s:
 1. `@Ring.bracket A _` which says `⁅a, b⁆ = a * b - b * a`
 2. `(@LieRingModule.ofAssociativeModule A _ A _ _).toBracket` which says `⁅a, b⁆ = a • b`
    (and thus `⁅a, b⁆ = a * b`)

See note [reducible non-instances] -/
abbrev LieRingModule.ofAssociativeModule : LieRingModule A M 
goal: LieRingModule A M

full_name: lie_eq_smul
code: theorem lie_eq_smul (a : A) (m : M) : ⁅a, m⁆ = a • m 
goal: ⁅a, m⁆ = a • m

full_name: LieAlgebra.ofAssociativeAlgebra
code: /-- An associative algebra gives rise to a Lie algebra by taking the bracket to be the ring
commutator. -/
instance (priority := 100) LieAlgebra.ofAssociativeAlgebra : LieAlgebra R A 
goal: LieAlgebra R A

full_name: LieModule.ofAssociativeModule
code: /-- A representation of an associative algebra `A` is also a representation of `A`, regarded as a
Lie algebra via the ring commutator.

See the comment at `LieRingModule.ofAssociativeModule` for why the possibility `M = A` means
this cannot be a global instance. -/
theorem LieModule.ofAssociativeModule : LieModule R A M 
goal: LieModule R A M

full_name: Module.End.instLieRingModule
code: instance Module.End.instLieRingModule : LieRingModule (Module.End R M) M 
goal: LieRingModule (Module.End R M) M

full_name: Module.End.instLieModule
code: instance Module.End.instLieModule : LieModule R (Module.End R M) M 
goal: LieModule R (Module.End R M) M

full_name: Module.End.lie_apply
code: @[simp] lemma Module.End.lie_apply (f : Module.End R M) (m : M) : ⁅f, m⁆ = f m 
goal: ⁅f, m⁆ = f m

full_name: AlgHom.toLieHom
code: /-- The map `ofAssociativeAlgebra` associating a Lie algebra to an associative algebra is
functorial. -/
def toLieHom : A →ₗ⁅R⁆ B 
goal: A →ₗ⁅R⁆ B

full_name: AlgHom.instCoeLieHom
code: instance : Coe (A →ₐ[R] B) (A →ₗ⁅R⁆ B) 
goal: Coe (A →ₐ[R] B) (A →ₗ⁅R⁆ B)

full_name: AlgHom.coe_toLieHom
code: @[simp]
theorem coe_toLieHom : ((f : A →ₗ⁅R⁆ B) : A → B) = f 
goal: ⇑f.toLieHom = ⇑f

full_name: AlgHom.toLieHom_apply
code: theorem toLieHom_apply (x : A) : f.toLieHom x = f x 
goal: f.toLieHom x = f x

full_name: AlgHom.toLieHom_id
code: @[simp]
theorem toLieHom_id : (AlgHom.id R A : A →ₗ⁅R⁆ A) = LieHom.id 
goal: (AlgHom.id R A).toLieHom = LieHom.id

full_name: AlgHom.toLieHom_comp
code: @[simp]
theorem toLieHom_comp : (g.comp f : A →ₗ⁅R⁆ C) = (g : B →ₗ⁅R⁆ C).comp (f : A →ₗ⁅R⁆ B) 
goal: (g.comp f).toLieHom = g.toLieHom.comp f.toLieHom

full_name: AlgHom.toLieHom_injective
code: theorem toLieHom_injective {f g : A →ₐ[R] B} (h : (f : A →ₗ⁅R⁆ B) = (g : A →ₗ⁅R⁆ B)) : f = g 
goal: f = g

full_name: LieModule.toEnd
code: /-- A Lie module yields a Lie algebra morphism into the linear endomorphisms of the module.

See also `LieModule.toModuleHom`. -/
@[simps]
def LieModule.toEnd : L →ₗ⁅R⁆ Module.End R M 
goal: L →ₗ⁅R⁆ Module.End R M

full_name: LieModule.toEnd_apply_apply
code: /-- A Lie module yields a Lie algebra morphism into the linear endomorphisms of the module.

See also `LieModule.toModuleHom`. -/
@[simps]
def LieModule.toEnd : L →ₗ⁅R⁆ Module.End R M 
goal: ((LieModule.toEnd R L M) x) m = ⁅x, m⁆

full_name: LieAlgebra.ad
code: /-- The adjoint action of a Lie algebra on itself. -/
def LieAlgebra.ad : L →ₗ⁅R⁆ Module.End R L 
goal: L →ₗ⁅R⁆ Module.End R L

full_name: LieAlgebra.ad_apply
code: @[simp]
theorem LieAlgebra.ad_apply (x y : L) : LieAlgebra.ad R L x y = ⁅x, y⁆ 
goal: ((LieAlgebra.ad R L) x) y = ⁅x, y⁆

full_name: LieModule.toEnd_module_end
code: @[simp]
theorem LieModule.toEnd_module_end :
    LieModule.toEnd R (Module.End R M) M = LieHom.id 
goal: LieModule.toEnd R (Module.End R M) M = LieHom.id

full_name: LieSubalgebra.toEnd_eq
code: theorem LieSubalgebra.toEnd_eq (K : LieSubalgebra R L) {x : K} :
    LieModule.toEnd R K M x = LieModule.toEnd R L M x 
goal: (LieModule.toEnd R (↥K) M) x = (LieModule.toEnd R L M) ↑x

full_name: LieSubalgebra.toEnd_mk
code: @[simp]
theorem LieSubalgebra.toEnd_mk (K : LieSubalgebra R L) {x : L} (hx : x ∈ K) :
    LieModule.toEnd R K M ⟨x, hx⟩ = LieModule.toEnd R L M x 
goal: (LieModule.toEnd R (↥K) M) ⟨x, hx⟩ = (LieModule.toEnd R L M) x

full_name: LieSubmodule.coe_toEnd
code: lemma LieSubmodule.coe_toEnd (N : LieSubmodule R L M) (x : L) (y : N) :
    (toEnd R L N x y : M) = toEnd R L M x y 
goal: ↑(((LieModule.toEnd R L ↥↑N) x) y) = ((LieModule.toEnd R L M) x) ↑y

full_name: LieSubmodule.coe_toEnd_pow
code: lemma LieSubmodule.coe_toEnd_pow (N : LieSubmodule R L M) (x : L) (y : N) (n : ℕ) :
    ((toEnd R L N x ^ n) y : M) = (toEnd R L M x ^ n) y 
goal: ↑(((LieModule.toEnd R L ↥↑N) x ^ n) y) = ((LieModule.toEnd R L M) x ^ n) ↑y

full_name: LieSubalgebra.coe_ad
code: lemma LieSubalgebra.coe_ad (H : LieSubalgebra R L) (x y : H) :
    (ad R H x y : L) = ad R L x y 
goal: ↑(((LieAlgebra.ad R ↥H) x) y) = ((LieAlgebra.ad R L) ↑x) ↑y

full_name: LieSubalgebra.coe_ad_pow
code: lemma LieSubalgebra.coe_ad_pow (H : LieSubalgebra R L) (x y : H) (n : ℕ) :
    ((ad R H x ^ n) y : L) = (ad R L x ^ n) y 
goal: ↑(((LieAlgebra.ad R ↥H) x ^ n) y) = ((LieAlgebra.ad R L) ↑x ^ n) ↑y

full_name: _aux_Mathlib_Algebra_Lie_OfAssociative___macroRules_termφ_1
code: local notation "φ" => LieModule.toEnd R L M
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Lie_OfAssociative___unexpand_LieModule_toEnd_1
code: local notation "φ" => LieModule.toEnd R L M
goal: Lean.PrettyPrinter.Unexpander

full_name: LieModule.toEnd_lie
code: lemma LieModule.toEnd_lie (x y : L) (z : M) :
    (φ x) ⁅y, z⁆ = ⁅ad R L x y, z⁆ + ⁅y, φ x z⁆ 
goal: ((LieModule.toEnd R L M) x) ⁅y, z⁆ = ⁅((LieAlgebra.ad R L) x) y, z⁆ + ⁅y, ((LieModule.toEnd R L M) x) z⁆

full_name: LieAlgebra.ad_lie
code: lemma LieAlgebra.ad_lie (x y z : L) :
    (ad R L x) ⁅y, z⁆ = ⁅ad R L x y, z⁆ + ⁅y, ad R L x z⁆ 
goal: ((LieAlgebra.ad R L) x) ⁅y, z⁆ = ⁅((LieAlgebra.ad R L) x) y, z⁆ + ⁅y, ((LieAlgebra.ad R L) x) z⁆

full_name: LieModule.toEnd_pow_lie
code: lemma LieModule.toEnd_pow_lie (x y : L) (z : M) (n : ℕ) :
    ((φ x) ^ n) ⁅y, z⁆ =
      ∑ ij ∈ antidiagonal n, n.choose ij.1 • ⁅((ad R L x) ^ ij.1) y, ((φ x) ^ ij.2) z⁆ 
goal: ((LieModule.toEnd R L M) x ^ n) ⁅y, z⁆ =
  ∑ ij ∈ Finset.antidiagonal n, n.choose ij.1 • ⁅((LieAlgebra.ad R L) x ^ ij.1) y, ((LieModule.toEnd R L M) x ^ ij.2) z⁆

full_name: LieAlgebra.ad_pow_lie
code: lemma LieAlgebra.ad_pow_lie (x y z : L) (n : ℕ) :
    ((ad R L x) ^ n) ⁅y, z⁆ =
      ∑ ij ∈ antidiagonal n, n.choose ij.1 • ⁅((ad R L x) ^ ij.1) y, ((ad R L x) ^ ij.2) z⁆ 
goal: ((LieAlgebra.ad R L) x ^ n) ⁅y, z⁆ =
  ∑ ij ∈ Finset.antidiagonal n, n.choose ij.1 • ⁅((LieAlgebra.ad R L) x ^ ij.1) y, ((LieAlgebra.ad R L) x ^ ij.2) z⁆

full_name: LieModule.toEnd_pow_comp_lieHom
code: lemma toEnd_pow_comp_lieHom :
    (toEnd R L M₂ x ^ k) ∘ₗ f = f ∘ₗ toEnd R L M x ^ k 
goal: ((LieModule.toEnd R L M₂) x ^ k) ∘ₗ ↑f = ↑f ∘ₗ (LieModule.toEnd R L M) x ^ k

full_name: LieModule.toEnd_pow_apply_map
code: lemma toEnd_pow_apply_map (m : M) :
    (toEnd R L M₂ x ^ k) (f m) = f ((toEnd R L M x ^ k) m) 
goal: ((LieModule.toEnd R L M₂) x ^ k) (f m) = f (((LieModule.toEnd R L M) x ^ k) m)

full_name: LieSubmodule.coe_map_toEnd_le
code: theorem coe_map_toEnd_le :
    (N : Submodule R M).map (LieModule.toEnd R L M x) ≤ N 
goal: Submodule.map ((LieModule.toEnd R L M) x) ↑N ≤ ↑N

full_name: LieSubmodule.toEnd_comp_subtype_mem
code: theorem toEnd_comp_subtype_mem (m : M) (hm : m ∈ (N : Submodule R M)) :
    (toEnd R L M x).comp (N : Submodule R M).subtype ⟨m, hm⟩ ∈ (N : Submodule R M) 
goal: ((LieModule.toEnd R L M) x ∘ₗ (↑N).subtype) ⟨m, hm⟩ ∈ ↑N

full_name: LieSubmodule.toEnd_restrict_eq_toEnd
code: @[simp]
theorem toEnd_restrict_eq_toEnd (h := N.toEnd_comp_subtype_mem x) :
    (toEnd R L M x).restrict h = toEnd R L N x 
goal: LinearMap.restrict ((LieModule.toEnd R L M) x) h = (LieModule.toEnd R L ↥↑N) x

full_name: LieSubmodule.mapsTo_pow_toEnd_sub_algebraMap
code: lemma mapsTo_pow_toEnd_sub_algebraMap {φ : R} {k : ℕ} {x : L} :
    MapsTo ((toEnd R L M x - algebraMap R (Module.End R M) φ) ^ k) N N 
goal: Set.MapsTo ⇑(((LieModule.toEnd R L M) x - (algebraMap R (Module.End R M)) φ) ^ k) ↑N ↑N

full_name: LieAlgebra.ad_eq_lmul_left_sub_lmul_right
code: theorem LieAlgebra.ad_eq_lmul_left_sub_lmul_right (A : Type v) [Ring A] [Algebra R A] :
    (ad R A : A → Module.End R A) = LinearMap.mulLeft R - LinearMap.mulRight R 
goal: ⇑(LieAlgebra.ad R A) = LinearMap.mulLeft R - LinearMap.mulRight R

full_name: LieSubalgebra.ad_comp_incl_eq
code: theorem LieSubalgebra.ad_comp_incl_eq (K : LieSubalgebra R L) (x : K) :
    (ad R L ↑x).comp (K.incl : K →ₗ[R] L) = (K.incl : K →ₗ[R] L).comp (ad R K x) 
goal: (LieAlgebra.ad R L) ↑x ∘ₗ ↑K.incl = ↑K.incl ∘ₗ (LieAlgebra.ad R ↥K) x

full_name: lieSubalgebraOfSubalgebra
code: /-- A subalgebra of an associative algebra is a Lie subalgebra of the associated Lie algebra. -/
def lieSubalgebraOfSubalgebra (R : Type u) [CommRing R] (A : Type v) [Ring A] [Algebra R A]
    (A' : Subalgebra R A) : LieSubalgebra R A 
goal: LieSubalgebra R A

full_name: LinearEquiv.lieConj
code: /-- A linear equivalence of two modules induces a Lie algebra equivalence of their endomorphisms. -/
def lieConj : Module.End R M₁ ≃ₗ⁅R⁆ Module.End R M₂ 
goal: Module.End R M₁ ≃ₗ⁅R⁆ Module.End R M₂

full_name: LinearEquiv.lieConj_apply
code: @[simp]
theorem lieConj_apply (f : Module.End R M₁) : e.lieConj f = e.conj f 
goal: e.lieConj f = e.conj f

full_name: LinearEquiv.lieConj_symm
code: @[simp]
theorem lieConj_symm : e.lieConj.symm = e.symm.lieConj 
goal: e.lieConj.symm = e.symm.lieConj

full_name: AlgEquiv.toLieEquiv
code: /-- An equivalence of associative algebras is an equivalence of associated Lie algebras. -/
def toLieEquiv : A₁ ≃ₗ⁅R⁆ A₂ 
goal: A₁ ≃ₗ⁅R⁆ A₂

full_name: AlgEquiv.toLieEquiv_apply
code: @[simp]
theorem toLieEquiv_apply (x : A₁) : e.toLieEquiv x = e x 
goal: e.toLieEquiv x = e x

full_name: AlgEquiv.toLieEquiv_symm_apply
code: @[simp]
theorem toLieEquiv_symm_apply (x : A₂) : e.toLieEquiv.symm x = e.symm x 
goal: e.toLieEquiv.symm x = e.symm x

full_name: LieAlgebra.conj_ad_apply
code: /-- Given an equivalence `e` of Lie algebras from `L` to `L'`, and an element `x : L`, the conjugate
of the endomorphism `ad(x)` of `L` by `e` is the endomorphism `ad(e x)` of `L'`. -/
@[simp]
lemma conj_ad_apply (e : L ≃ₗ⁅R⁆ L') (x : L) : LinearEquiv.conj e (ad R L x) = ad R L' (e x) 
goal: e.toLinearEquiv.conj ((LieAlgebra.ad R L) x) = (LieAlgebra.ad R L') (e x)