File: Mathlib/Algebra/Lie/DirectSum.lean

full_name: DirectSum.instLieRingModule
code: instance : LieRingModule L (⨁ i, M i) 
goal: LieRingModule L (DirectSum ι fun i => M i)

full_name: DirectSum.lie_module_bracket_apply
code: @[simp]
theorem lie_module_bracket_apply (x : L) (m : ⨁ i, M i) (i : ι) : ⁅x, m⁆ i = ⁅x, m i⁆ 
goal: ⁅x, m⁆ i = ⁅x, m i⁆

full_name: DirectSum.instLieModule
code: instance : LieModule R L (⨁ i, M i) 
goal: LieModule R L (DirectSum ι fun i => M i)

full_name: DirectSum.lieModuleOf
code: /-- The inclusion of each component into a direct sum as a morphism of Lie modules. -/
def lieModuleOf [DecidableEq ι] (j : ι) : M j →ₗ⁅R,L⁆ ⨁ i, M i 
goal: M j →ₗ⁅R,L⁆ DirectSum ι fun i => M i

full_name: DirectSum.lieModuleComponent
code: /-- The projection map onto one component, as a morphism of Lie modules. -/
def lieModuleComponent (j : ι) : (⨁ i, M i) →ₗ⁅R,L⁆ M j 
goal: (DirectSum ι fun i => M i) →ₗ⁅R,L⁆ M j

full_name: DirectSum.lieRing
code: instance lieRing : LieRing (⨁ i, L i) 
goal: LieRing (DirectSum ι fun i => L i)

full_name: DirectSum.bracket_apply
code: @[simp]
theorem bracket_apply (x y : ⨁ i, L i) (i : ι) : ⁅x, y⁆ i = ⁅x i, y i⁆ 
goal: ⁅x, y⁆ i = ⁅x i, y i⁆

full_name: DirectSum.lie_of_same
code: theorem lie_of_same [DecidableEq ι] {i : ι} (x y : L i) :
    ⁅of L i x, of L i y⁆ = of L i ⁅x, y⁆ 
goal: ⁅(DirectSum.of L i) x, (DirectSum.of L i) y⁆ = (DirectSum.of L i) ⁅x, y⁆

full_name: DirectSum.lie_of_of_ne
code: theorem lie_of_of_ne [DecidableEq ι] {i j : ι} (hij : i ≠ j) (x : L i) (y : L j) :
    ⁅of L i x, of L j y⁆ = 0 
goal: ⁅(DirectSum.of L i) x, (DirectSum.of L j) y⁆ = 0

full_name: DirectSum.lie_of
code: @[simp]
theorem lie_of [DecidableEq ι] {i j : ι} (x : L i) (y : L j) :
    ⁅of L i x, of L j y⁆ = if hij : i = j then of L i ⁅x, hij.symm.recOn y⁆ else 0 
goal: ⁅(DirectSum.of L i) x, (DirectSum.of L j) y⁆ = if hij : i = j then (DirectSum.of L i) ⁅x, Eq.recOn ⋯ y⁆ else 0

full_name: DirectSum.lieAlgebra
code: instance lieAlgebra : LieAlgebra R (⨁ i, L i) 
goal: LieAlgebra R (DirectSum ι fun i => L i)

full_name: DirectSum.lieAlgebraOf_apply
code: /-- The inclusion of each component into the direct sum as morphism of Lie algebras. -/
@[simps]
def lieAlgebraOf [DecidableEq ι] (j : ι) : L j →ₗ⁅R⁆ ⨁ i, L i 
goal: (DirectSum.lieAlgebraOf R ι L j) a = (DirectSum.of L j) a

full_name: DirectSum.lieAlgebraOf
code: /-- The inclusion of each component into the direct sum as morphism of Lie algebras. -/
@[simps]
def lieAlgebraOf [DecidableEq ι] (j : ι) : L j →ₗ⁅R⁆ ⨁ i, L i 
goal: L j →ₗ⁅R⁆ DirectSum ι fun i => L i

full_name: DirectSum.lieAlgebraComponent_apply
code: /-- The projection map onto one component, as a morphism of Lie algebras. -/
@[simps]
def lieAlgebraComponent (j : ι) : (⨁ i, L i) →ₗ⁅R⁆ L j 
goal: (DirectSum.lieAlgebraComponent R ι L j) a = (DirectSum.component R ι L j) a

full_name: DirectSum.lieAlgebraComponent
code: /-- The projection map onto one component, as a morphism of Lie algebras. -/
@[simps]
def lieAlgebraComponent (j : ι) : (⨁ i, L i) →ₗ⁅R⁆ L j 
goal: (DirectSum ι fun i => L i) →ₗ⁅R⁆ L j

full_name: DirectSum.lieAlgebra_ext
code: @[ext]
theorem lieAlgebra_ext {x y : ⨁ i, L i}
    (h : ∀ i, lieAlgebraComponent R ι L i x = lieAlgebraComponent R ι L i y) : x = y 
goal: x = y

full_name: DirectSum.toLieAlgebra_apply
code: /-- Given a family of Lie algebras `L i`, together with a family of morphisms of Lie algebras
`f i : L i →ₗ⁅R⁆ L'` into a fixed Lie algebra `L'`, we have a natural linear map:
`(⨁ i, L i) →ₗ[R] L'`. If in addition `⁅f i x, f j y⁆ = 0` for any `x ∈ L i` and `y ∈ L j` (`i ≠ j`)
then this map is a morphism of Lie algebras. -/
@[simps]
def toLieAlgebra [DecidableEq ι] (L' : Type w₁) [LieRing L'] [LieAlgebra R L']
    (f : ∀ i, L i →ₗ⁅R⁆ L') (hf : Pairwise fun i j => ∀ (x : L i) (y : L j), ⁅f i x, f j y⁆ = 0) :
    (⨁ i, L i) →ₗ⁅R⁆ L' 
goal: (DirectSum.toLieAlgebra L' f hf) a = (DirectSum.toModule R ι L' fun i => ↑(f i)) a

full_name: DirectSum.toLieAlgebra
code: /-- Given a family of Lie algebras `L i`, together with a family of morphisms of Lie algebras
`f i : L i →ₗ⁅R⁆ L'` into a fixed Lie algebra `L'`, we have a natural linear map:
`(⨁ i, L i) →ₗ[R] L'`. If in addition `⁅f i x, f j y⁆ = 0` for any `x ∈ L i` and `y ∈ L j` (`i ≠ j`)
then this map is a morphism of Lie algebras. -/
@[simps]
def toLieAlgebra [DecidableEq ι] (L' : Type w₁) [LieRing L'] [LieAlgebra R L']
    (f : ∀ i, L i →ₗ⁅R⁆ L') (hf : Pairwise fun i j => ∀ (x : L i) (y : L j), ⁅f i x, f j y⁆ = 0) :
    (⨁ i, L i) →ₗ⁅R⁆ L' 
goal: (DirectSum ι fun i => L i) →ₗ⁅R⁆ L'

full_name: DirectSum.lieRingOfIdeals
code: /-- The fact that this instance is necessary seems to be a bug in typeclass inference. See
[this Zulip thread](https://leanprover.zulipchat.com/#narrow/stream/113488-general/topic/
Typeclass.20resolution.20under.20binders/near/245151099). -/
instance lieRingOfIdeals : LieRing (⨁ i, I i) 
goal: LieRing (DirectSum ι fun i => ↥↑(I i))

full_name: DirectSum.lieAlgebraOfIdeals
code: /-- See `DirectSum.lieRingOfIdeals` comment. -/
instance lieAlgebraOfIdeals : LieAlgebra R (⨁ i, I i) 
goal: LieAlgebra R (DirectSum ι fun i => ↥↑(I i))