File: Mathlib/Algebra/Lie/Normalizer.lean

full_name: LieSubmodule.normalizer
code: /-- The normalizer of a Lie submodule.

See also `LieSubmodule.idealizer`. -/
def normalizer : LieSubmodule R L M 
goal: LieSubmodule R L M

full_name: LieSubmodule.mem_normalizer
code: @[simp]
theorem mem_normalizer (m : M) : m ∈ N.normalizer ↔ ∀ x : L, ⁅x, m⁆ ∈ N 
goal: m ∈ N.normalizer ↔ ∀ (x : L), ⁅x, m⁆ ∈ N

full_name: LieSubmodule.le_normalizer
code: @[simp]
theorem le_normalizer : N ≤ N.normalizer 
goal: N ≤ N.normalizer

full_name: LieSubmodule.normalizer_inf
code: theorem normalizer_inf : (N₁ ⊓ N₂).normalizer = N₁.normalizer ⊓ N₂.normalizer 
goal: (N₁ ⊓ N₂).normalizer = N₁.normalizer ⊓ N₂.normalizer

full_name: LieSubmodule.normalizer_mono
code: @[gcongr, mono]
theorem normalizer_mono (h : N₁ ≤ N₂) : normalizer N₁ ≤ normalizer N₂ 
goal: N₁.normalizer ≤ N₂.normalizer

full_name: LieSubmodule.monotone_normalizer
code: theorem monotone_normalizer : Monotone (normalizer : LieSubmodule R L M → LieSubmodule R L M) 
goal: Monotone LieSubmodule.normalizer

full_name: LieSubmodule.comap_normalizer
code: @[simp]
theorem comap_normalizer (f : M' →ₗ⁅R,L⁆ M) : N.normalizer.comap f = (N.comap f).normalizer 
goal: LieSubmodule.comap f N.normalizer = (LieSubmodule.comap f N).normalizer

full_name: LieSubmodule.top_lie_le_iff_le_normalizer
code: theorem top_lie_le_iff_le_normalizer (N' : LieSubmodule R L M) :
    ⁅(⊤ : LieIdeal R L), N⁆ ≤ N' ↔ N ≤ N'.normalizer 
goal: ⁅⊤, N⁆ ≤ N' ↔ N ≤ N'.normalizer

full_name: LieSubmodule.gc_top_lie_normalizer
code: theorem gc_top_lie_normalizer :
    GaloisConnection (fun N : LieSubmodule R L M => ⁅(⊤ : LieIdeal R L), N⁆) normalizer 
goal: GaloisConnection (fun N => ⁅⊤, N⁆) LieSubmodule.normalizer

full_name: LieSubmodule.normalizer_bot_eq_maxTrivSubmodule
code: theorem normalizer_bot_eq_maxTrivSubmodule :
    (⊥ : LieSubmodule R L M).normalizer = LieModule.maxTrivSubmodule R L M 
goal: ⊥.normalizer = LieModule.maxTrivSubmodule R L M

full_name: LieSubmodule.idealizer
code: /-- The idealizer of a Lie submodule.

See also `LieSubmodule.normalizer`. -/
def idealizer : LieIdeal R L 
goal: LieIdeal R L

full_name: LieSubmodule.mem_idealizer
code: @[simp]
lemma mem_idealizer {x : L} : x ∈ N.idealizer ↔ ∀ m : M, ⁅x, m⁆ ∈ N 
goal: x ∈ N.idealizer ↔ ∀ (m : M), ⁅x, m⁆ ∈ N

full_name: LieIdeal.idealizer_eq_normalizer
code: @[simp]
lemma _root_.LieIdeal.idealizer_eq_normalizer (I : LieIdeal R L) :
    I.idealizer = I.normalizer 
goal: LieSubmodule.idealizer I = LieSubmodule.normalizer I

full_name: LieSubalgebra.normalizer
code: /-- Regarding a Lie subalgebra `H ⊆ L` as a module over itself, its normalizer is in fact a Lie
subalgebra. -/
def normalizer : LieSubalgebra R L 
goal: LieSubalgebra R L

full_name: LieSubalgebra.mem_normalizer_iff'
code: theorem mem_normalizer_iff' (x : L) : x ∈ H.normalizer ↔ ∀ y : L, y ∈ H → ⁅y, x⁆ ∈ H 
goal: x ∈ H.normalizer ↔ ∀ y ∈ H, ⁅y, x⁆ ∈ H

full_name: LieSubalgebra.mem_normalizer_iff
code: theorem mem_normalizer_iff (x : L) : x ∈ H.normalizer ↔ ∀ y : L, y ∈ H → ⁅x, y⁆ ∈ H 
goal: x ∈ H.normalizer ↔ ∀ y ∈ H, ⁅x, y⁆ ∈ H

full_name: LieSubalgebra.le_normalizer
code: theorem le_normalizer : H ≤ H.normalizer 
goal: H ≤ H.normalizer

full_name: LieSubalgebra.coe_normalizer_eq_normalizer
code: theorem coe_normalizer_eq_normalizer :
    (H.toLieSubmodule.normalizer : Submodule R L) = H.normalizer 
goal: ↑H.toLieSubmodule.normalizer = H.normalizer.toSubmodule

full_name: LieSubalgebra.lie_mem_sup_of_mem_normalizer
code: theorem lie_mem_sup_of_mem_normalizer {x y z : L} (hx : x ∈ H.normalizer) (hy : y ∈ (R ∙ x) ⊔ ↑H)
    (hz : z ∈ (R ∙ x) ⊔ ↑H) : ⁅y, z⁆ ∈ (R ∙ x) ⊔ ↑H 
goal: ⁅y, z⁆ ∈ Submodule.span R {x} ⊔ H.toSubmodule

full_name: LieSubalgebra.ideal_in_normalizer
code: /-- A Lie subalgebra is an ideal of its normalizer. -/
theorem ideal_in_normalizer {x y : L} (hx : x ∈ H.normalizer) (hy : y ∈ H) : ⁅x, y⁆ ∈ H 
goal: ⁅x, y⁆ ∈ H

full_name: LieSubalgebra.exists_nested_lieIdeal_ofLe_normalizer
code: /-- A Lie subalgebra `H` is an ideal of any Lie subalgebra `K` containing `H` and contained in the
normalizer of `H`. -/
theorem exists_nested_lieIdeal_ofLe_normalizer {K : LieSubalgebra R L} (h₁ : H ≤ K)
    (h₂ : K ≤ H.normalizer) : ∃ I : LieIdeal R K, (I : LieSubalgebra R K) = ofLe h₁ 
goal: ∃ I, lieIdealSubalgebra R (↥K) I = LieSubalgebra.ofLe h₁

full_name: LieSubalgebra.normalizer_eq_self_iff
code: theorem normalizer_eq_self_iff :
    H.normalizer = H ↔ (LieModule.maxTrivSubmodule R H <| L ⧸ H.toLieSubmodule) = ⊥ 
goal: H.normalizer = H ↔ LieModule.maxTrivSubmodule R (↥H) (L ⧸ H.toLieSubmodule) = ⊥