File: Mathlib/Algebra/Lie/IdealOperations.lean

full_name: LieSubmodule.hasBracket
code: /-- Given a Lie module `M` over a Lie algebra `L`, the set of Lie ideals of `L` acts on the set
of submodules of `M`. -/
instance hasBracket : Bracket (LieIdeal R L) (LieSubmodule R L M) 
goal: Bracket (LieIdeal R L) (LieSubmodule R L M)

full_name: LieSubmodule.lieIdeal_oper_eq_span
code: theorem lieIdeal_oper_eq_span :
    ⁅I, N⁆ = lieSpan R L { m | ∃ (x : I) (n : N), ⁅(x : L), (n : M)⁆ = m } 
goal: ⁅I, N⁆ = LieSubmodule.lieSpan R L {m | ∃ x n, ⁅↑x, ↑n⁆ = m}

full_name: LieSubmodule.lieIdeal_oper_eq_linear_span
code: /-- See also `LieSubmodule.lieIdeal_oper_eq_linear_span'` and
`LieSubmodule.lieIdeal_oper_eq_tensor_map_range`. -/
theorem lieIdeal_oper_eq_linear_span :
    (↑⁅I, N⁆ : Submodule R M) =
      Submodule.span R { m | ∃ (x : I) (n : N), ⁅(x : L), (n : M)⁆ = m } 
goal: ↑⁅I, N⁆ = Submodule.span R {m | ∃ x n, ⁅↑x, ↑n⁆ = m}

full_name: LieSubmodule.lieIdeal_oper_eq_linear_span'
code: theorem lieIdeal_oper_eq_linear_span' :
    (↑⁅I, N⁆ : Submodule R M) = Submodule.span R { m | ∃ x ∈ I, ∃ n ∈ N, ⁅x, n⁆ = m } 
goal: ↑⁅I, N⁆ = Submodule.span R {m | ∃ x ∈ I, ∃ n ∈ N, ⁅x, n⁆ = m}

full_name: LieSubmodule.lie_le_iff
code: theorem lie_le_iff : ⁅I, N⁆ ≤ N' ↔ ∀ x ∈ I, ∀ m ∈ N, ⁅x, m⁆ ∈ N' 
goal: ⁅I, N⁆ ≤ N' ↔ ∀ x ∈ I, ∀ m ∈ N, ⁅x, m⁆ ∈ N'

full_name: LieSubmodule.lie_coe_mem_lie
code: theorem lie_coe_mem_lie (x : I) (m : N) : ⁅(x : L), (m : M)⁆ ∈ ⁅I, N⁆ 
goal: ⁅↑x, ↑m⁆ ∈ ⁅I, N⁆

full_name: LieSubmodule.lie_mem_lie
code: theorem lie_mem_lie {x : L} {m : M} (hx : x ∈ I) (hm : m ∈ N) : ⁅x, m⁆ ∈ ⁅I, N⁆ 
goal: ⁅x, m⁆ ∈ ⁅I, N⁆

full_name: LieSubmodule.lie_comm
code: theorem lie_comm : ⁅I, J⁆ = ⁅J, I⁆ 
goal: ⁅I, J⁆ = ⁅J, I⁆

full_name: LieSubmodule.lie_le_right
code: theorem lie_le_right : ⁅I, N⁆ ≤ N 
goal: ⁅I, N⁆ ≤ N

full_name: LieSubmodule.lie_le_left
code: theorem lie_le_left : ⁅I, J⁆ ≤ I 
goal: ⁅I, J⁆ ≤ I

full_name: LieSubmodule.lie_le_inf
code: theorem lie_le_inf : ⁅I, J⁆ ≤ I ⊓ J 
goal: ⁅I, J⁆ ≤ I ⊓ J

full_name: LieSubmodule.lie_bot
code: @[simp]
theorem lie_bot : ⁅I, (⊥ : LieSubmodule R L M)⁆ = ⊥ 
goal: ⁅I, ⊥⁆ = ⊥

full_name: LieSubmodule.bot_lie
code: @[simp]
theorem bot_lie : ⁅(⊥ : LieIdeal R L), N⁆ = ⊥ 
goal: ⁅⊥, N⁆ = ⊥

full_name: LieSubmodule.lie_eq_bot_iff
code: theorem lie_eq_bot_iff : ⁅I, N⁆ = ⊥ ↔ ∀ x ∈ I, ∀ m ∈ N, ⁅(x : L), m⁆ = 0 
goal: ⁅I, N⁆ = ⊥ ↔ ∀ x ∈ I, ∀ m ∈ N, ⁅x, m⁆ = 0

full_name: LieSubmodule.mono_lie
code: theorem mono_lie (h₁ : I ≤ J) (h₂ : N ≤ N') : ⁅I, N⁆ ≤ ⁅J, N'⁆ 
goal: ⁅I, N⁆ ≤ ⁅J, N'⁆

full_name: LieSubmodule.mono_lie_left
code: theorem mono_lie_left (h : I ≤ J) : ⁅I, N⁆ ≤ ⁅J, N⁆ 
goal: ⁅I, N⁆ ≤ ⁅J, N⁆

full_name: LieSubmodule.mono_lie_right
code: theorem mono_lie_right (h : N ≤ N') : ⁅I, N⁆ ≤ ⁅I, N'⁆ 
goal: ⁅I, N⁆ ≤ ⁅I, N'⁆

full_name: LieSubmodule.lie_sup
code: @[simp]
theorem lie_sup : ⁅I, N ⊔ N'⁆ = ⁅I, N⁆ ⊔ ⁅I, N'⁆ 
goal: ⁅I, N ⊔ N'⁆ = ⁅I, N⁆ ⊔ ⁅I, N'⁆

full_name: LieSubmodule.sup_lie
code: @[simp]
theorem sup_lie : ⁅I ⊔ J, N⁆ = ⁅I, N⁆ ⊔ ⁅J, N⁆ 
goal: ⁅I ⊔ J, N⁆ = ⁅I, N⁆ ⊔ ⁅J, N⁆

full_name: LieSubmodule.lie_inf
code: theorem lie_inf : ⁅I, N ⊓ N'⁆ ≤ ⁅I, N⁆ ⊓ ⁅I, N'⁆ 
goal: ⁅I, N ⊓ N'⁆ ≤ ⁅I, N⁆ ⊓ ⁅I, N'⁆

full_name: LieSubmodule.inf_lie
code: theorem inf_lie : ⁅I ⊓ J, N⁆ ≤ ⁅I, N⁆ ⊓ ⁅J, N⁆ 
goal: ⁅I ⊓ J, N⁆ ≤ ⁅I, N⁆ ⊓ ⁅J, N⁆

full_name: LieSubmodule.map_bracket_eq
code: theorem map_bracket_eq : map f ⁅I, N⁆ = ⁅I, map f N⁆ 
goal: LieSubmodule.map f ⁅I, N⁆ = ⁅I, LieSubmodule.map f N⁆

full_name: LieSubmodule.map_comap_le
code: theorem map_comap_le : map f (comap f N₂) ≤ N₂ 
goal: LieSubmodule.map f (LieSubmodule.comap f N₂) ≤ N₂

full_name: LieSubmodule.map_comap_eq
code: theorem map_comap_eq (hf : N₂ ≤ f.range) : map f (comap f N₂) = N₂ 
goal: LieSubmodule.map f (LieSubmodule.comap f N₂) = N₂

full_name: LieSubmodule.le_comap_map
code: theorem le_comap_map : N ≤ comap f (map f N) 
goal: N ≤ LieSubmodule.comap f (LieSubmodule.map f N)

full_name: LieSubmodule.comap_map_eq
code: theorem comap_map_eq (hf : f.ker = ⊥) : comap f (map f N) = N 
goal: LieSubmodule.comap f (LieSubmodule.map f N) = N

full_name: LieSubmodule.comap_bracket_eq
code: theorem comap_bracket_eq (hf₁ : f.ker = ⊥) (hf₂ : N₂ ≤ f.range) :
    comap f ⁅I, N₂⁆ = ⁅I, comap f N₂⁆ 
goal: LieSubmodule.comap f ⁅I, N₂⁆ = ⁅I, LieSubmodule.comap f N₂⁆

full_name: LieSubmodule.map_comap_incl
code: @[simp]
theorem map_comap_incl : map N.incl (comap N.incl N') = N ⊓ N' 
goal: LieSubmodule.map N.incl (LieSubmodule.comap N.incl N') = N ⊓ N'

full_name: LieIdeal.map_bracket_le
code: /-- Note that the inequality can be strict; e.g., the inclusion of an Abelian subalgebra of a
simple algebra. -/
theorem map_bracket_le {I₁ I₂ : LieIdeal R L} : map f ⁅I₁, I₂⁆ ≤ ⁅map f I₁, map f I₂⁆ 
goal: LieIdeal.map f ⁅I₁, I₂⁆ ≤ ⁅LieIdeal.map f I₁, LieIdeal.map f I₂⁆

full_name: LieIdeal.map_bracket_eq
code: theorem map_bracket_eq {I₁ I₂ : LieIdeal R L} (h : Function.Surjective f) :
    map f ⁅I₁, I₂⁆ = ⁅map f I₁, map f I₂⁆ 
goal: LieIdeal.map f ⁅I₁, I₂⁆ = ⁅LieIdeal.map f I₁, LieIdeal.map f I₂⁆

full_name: LieIdeal.comap_bracket_le
code: theorem comap_bracket_le {J₁ J₂ : LieIdeal R L'} : ⁅comap f J₁, comap f J₂⁆ ≤ comap f ⁅J₁, J₂⁆ 
goal: ⁅LieIdeal.comap f J₁, LieIdeal.comap f J₂⁆ ≤ LieIdeal.comap f ⁅J₁, J₂⁆

full_name: LieIdeal.map_comap_incl
code: theorem map_comap_incl {I₁ I₂ : LieIdeal R L} : map I₁.incl (comap I₁.incl I₂) = I₁ ⊓ I₂ 
goal: LieIdeal.map I₁.incl (LieIdeal.comap I₁.incl I₂) = I₁ ⊓ I₂

full_name: LieIdeal.comap_bracket_eq
code: theorem comap_bracket_eq {J₁ J₂ : LieIdeal R L'} (h : f.IsIdealMorphism) :
    comap f ⁅f.idealRange ⊓ J₁, f.idealRange ⊓ J₂⁆ = ⁅comap f J₁, comap f J₂⁆ ⊔ f.ker 
goal: LieIdeal.comap f ⁅f.idealRange ⊓ J₁, f.idealRange ⊓ J₂⁆ = ⁅LieIdeal.comap f J₁, LieIdeal.comap f J₂⁆ ⊔ f.ker

full_name: LieIdeal.map_comap_bracket_eq
code: theorem map_comap_bracket_eq {J₁ J₂ : LieIdeal R L'} (h : f.IsIdealMorphism) :
    map f ⁅comap f J₁, comap f J₂⁆ = ⁅f.idealRange ⊓ J₁, f.idealRange ⊓ J₂⁆ 
goal: LieIdeal.map f ⁅LieIdeal.comap f J₁, LieIdeal.comap f J₂⁆ = ⁅f.idealRange ⊓ J₁, f.idealRange ⊓ J₂⁆

full_name: LieIdeal.comap_bracket_incl
code: theorem comap_bracket_incl {I₁ I₂ : LieIdeal R L} :
    ⁅comap I.incl I₁, comap I.incl I₂⁆ = comap I.incl ⁅I ⊓ I₁, I ⊓ I₂⁆ 
goal: ⁅LieIdeal.comap I.incl I₁, LieIdeal.comap I.incl I₂⁆ = LieIdeal.comap I.incl ⁅I ⊓ I₁, I ⊓ I₂⁆

full_name: LieIdeal.comap_bracket_incl_of_le
code: /-- This is a very useful result; it allows us to use the fact that inclusion distributes over the
Lie bracket operation on ideals, subject to the conditions shown. -/
theorem comap_bracket_incl_of_le {I₁ I₂ : LieIdeal R L} (h₁ : I₁ ≤ I) (h₂ : I₂ ≤ I) :
    ⁅comap I.incl I₁, comap I.incl I₂⁆ = comap I.incl ⁅I₁, I₂⁆ 
goal: ⁅LieIdeal.comap I.incl I₁, LieIdeal.comap I.incl I₂⁆ = LieIdeal.comap I.incl ⁅I₁, I₂⁆