l3lab/ntp-mathlib huggingface dataset:
/-- The normalizer of a Lie submodule.

See also `LieSubmodule.idealizer`. -/
def normalizer : LieSubmodule R L M where
  carrier := {m | ∀ x : L, ⁅x, m⁆ ∈ N}
  add_mem' hm₁ hm₂ x := by rw [lie_add]; exact N.add_mem' (hm₁ x) (hm₂ x)
  zero_mem' x := by simp
  smul_mem' t m hm x := by rw [lie_smul]; exact N.smul_mem' t (hm x)
  lie_mem {x m} hm y := by 

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
x : L
m : M
hm :
  m ∈
    {
            toAddSubmonoid :=
              {
                toAddSubsemigroup :=
                  { carrier := {m | ∀ (x : L), ⁅x, m⁆ ∈ N},
                    add_mem' :=
                      (_ :
                        ∀ {a b : M},
                          a ∈ {m | ∀ (x : L), ⁅x, m⁆ ∈ N} →
                            b ∈ {m | ∀ (x : L), ⁅x, m⁆ ∈ N} → ∀ (x : L), ⁅x, a + b⁆ ∈ N) },
                zero_mem' := (_ : ∀ (x : L), ⁅x, 0⁆ ∈ N) },
            smul_mem' :=
              (_ :
                ∀ (t : R),
                  ∀
                    m ∈
                      {
                            toAddSubsemigroup :=
                              { carrier := {m | ∀ (x : L), ⁅x, m⁆ ∈ N},
                                add_mem' :=
                                  (_ :
                                    ∀ {a b : M},
                                      a ∈ {m | ∀ (x : L), ⁅x, m⁆ ∈ N} →
                                        b ∈ {m | ∀ (x : L), ⁅x, m⁆ ∈ N} → ∀ (x : L), ⁅x, a + b⁆ ∈ N) },
                            zero_mem' := (_ : ∀ (x : L), ⁅x, 0⁆ ∈ N) }.toAddSubsemigroup.carrier,
                    ∀ (x : L), ⁅x, t • m⁆ ∈ N) }.toAddSubmonoid.toAddSubsemigroup.carrier
y : L
⊢ ⁅y, ⁅x, m⁆⁆ ∈ N

Next tactic:
rw [leibniz_lie]
/-- The normalizer of a Lie submodule.

See also `LieSubmodule.idealizer`. -/
def normalizer : LieSubmodule R L M where
  carrier := {m | ∀ x : L, ⁅x, m⁆ ∈ N}
  add_mem' hm₁ hm₂ x := by rw [lie_add]; exact N.add_mem' (hm₁ x) (hm₂ x)
  zero_mem' x := by simp
  smul_mem' t m hm x := by rw [lie_smul]; exact N.smul_mem' t (hm x)
  lie_mem {x m} hm y := by rw [leibniz_lie]; 

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
x : L
m : M
hm :
  m ∈
    {
            toAddSubmonoid :=
              {
                toAddSubsemigroup :=
                  { carrier := {m | ∀ (x : L), ⁅x, m⁆ ∈ N},
                    add_mem' :=
                      (_ :
                        ∀ {a b : M},
                          a ∈ {m | ∀ (x : L), ⁅x, m⁆ ∈ N} →
                            b ∈ {m | ∀ (x : L), ⁅x, m⁆ ∈ N} → ∀ (x : L), ⁅x, a + b⁆ ∈ N) },
                zero_mem' := (_ : ∀ (x : L), ⁅x, 0⁆ ∈ N) },
            smul_mem' :=
              (_ :
                ∀ (t : R),
                  ∀
                    m ∈
                      {
                            toAddSubsemigroup :=
                              { carrier := {m | ∀ (x : L), ⁅x, m⁆ ∈ N},
                                add_mem' :=
                                  (_ :
                                    ∀ {a b : M},
                                      a ∈ {m | ∀ (x : L), ⁅x, m⁆ ∈ N} →
                                        b ∈ {m | ∀ (x : L), ⁅x, m⁆ ∈ N} → ∀ (x : L), ⁅x, a + b⁆ ∈ N) },
                            zero_mem' := (_ : ∀ (x : L), ⁅x, 0⁆ ∈ N) }.toAddSubsemigroup.carrier,
                    ∀ (x : L), ⁅x, t • m⁆ ∈ N) }.toAddSubmonoid.toAddSubsemigroup.carrier
y : L
⊢ ⁅⁅y, x⁆, m⁆ + ⁅x, ⁅y, m⁆⁆ ∈ N

Next tactic:
exact N.add_mem' (hm ⁅y, x⁆) (N.lie_mem (hm y))
@[simp]
theorem le_normalizer : N ≤ N.normalizer := by
  

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
⊢ N ≤ normalizer N

Next tactic:
intro m hm
@[simp]
theorem le_normalizer : N ≤ N.normalizer := by
  intro m hm
  

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
m : M
hm : m ∈ N
⊢ m ∈ normalizer N

Next tactic:
rw [mem_normalizer]
@[simp]
theorem le_normalizer : N ≤ N.normalizer := by
  intro m hm
  rw [mem_normalizer]
  

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
m : M
hm : m ∈ N
⊢ ∀ (x : L), ⁅x, m⁆ ∈ N

Next tactic:
exact fun x => N.lie_mem hm
theorem normalizer_inf : (N₁ ⊓ N₂).normalizer = N₁.normalizer ⊓ N₂.normalizer := by
  

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
⊢ normalizer (N₁ ⊓ N₂) = normalizer N₁ ⊓ normalizer N₂

Next tactic:
ext
theorem normalizer_inf : (N₁ ⊓ N₂).normalizer = N₁.normalizer ⊓ N₂.normalizer := by
  ext; 

Proof state:
case h
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
m✝ : M
⊢ m✝ ∈ normalizer (N₁ ⊓ N₂) ↔ m✝ ∈ normalizer N₁ ⊓ normalizer N₂

Next tactic:
simp [← forall_and]
@[mono]
theorem monotone_normalizer : Monotone (normalizer : LieSubmodule R L M → LieSubmodule R L M) := by
  

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
⊢ Monotone normalizer

Next tactic:
intro N₁ N₂ h m hm
@[mono]
theorem monotone_normalizer : Monotone (normalizer : LieSubmodule R L M → LieSubmodule R L M) := by
  intro N₁ N₂ h m hm
  

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁✝ N₂✝ N₁ N₂ : LieSubmodule R L M
h : N₁ ≤ N₂
m : M
hm : m ∈ normalizer N₁
⊢ m ∈ normalizer N₂

Next tactic:
rw [mem_normalizer] at hm ⊢
@[mono]
theorem monotone_normalizer : Monotone (normalizer : LieSubmodule R L M → LieSubmodule R L M) := by
  intro N₁ N₂ h m hm
  rw [mem_normalizer] at hm ⊢
  

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁✝ N₂✝ N₁ N₂ : LieSubmodule R L M
h : N₁ ≤ N₂
m : M
hm : ∀ (x : L), ⁅x, m⁆ ∈ N₁
⊢ ∀ (x : L), ⁅x, m⁆ ∈ N₂

Next tactic:
exact fun x => h (hm x)
@[simp]
theorem comap_normalizer (f : M' →ₗ⁅R,L⁆ M) : N.normalizer.comap f = (N.comap f).normalizer := by
  

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
f : M' →ₗ⁅R,L⁆ M
⊢ comap f (normalizer N) = normalizer (comap f N)

Next tactic:
ext
@[simp]
theorem comap_normalizer (f : M' →ₗ⁅R,L⁆ M) : N.normalizer.comap f = (N.comap f).normalizer := by
  ext; 

Proof state:
case h
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
f : M' →ₗ⁅R,L⁆ M
m✝ : M'
⊢ m✝ ∈ comap f (normalizer N) ↔ m✝ ∈ normalizer (comap f N)

Next tactic:
simp
theorem top_lie_le_iff_le_normalizer (N' : LieSubmodule R L M) :
    ⁅(⊤ : LieIdeal R L), N⁆ ≤ N' ↔ N ≤ N'.normalizer := by 

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ N' : LieSubmodule R L M
⊢ ⁅⊤, N⁆ ≤ N' ↔ N ≤ normalizer N'

Next tactic:
rw [lie_le_iff]
theorem top_lie_le_iff_le_normalizer (N' : LieSubmodule R L M) :
    ⁅(⊤ : LieIdeal R L), N⁆ ≤ N' ↔ N ≤ N'.normalizer := by rw [lie_le_iff]; 

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ N' : LieSubmodule R L M
⊢ (∀ x ∈ ⊤, ∀ m ∈ N, ⁅x, m⁆ ∈ N') ↔ N ≤ normalizer N'

Next tactic:
tauto
/-- The idealizer of a Lie submodule.

See also `LieSubmodule.normalizer`. -/
def idealizer : LieIdeal R L where
  carrier := {x : L | ∀ m : M, ⁅x, m⁆ ∈ N}
  add_mem' := fun {x} {y} hx hy m ↦ by 

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
x y : L
hx : x ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N}
hy : y ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N}
m : M
⊢ ⁅x + y, m⁆ ∈ N

Next tactic:
rw [add_lie]
/-- The idealizer of a Lie submodule.

See also `LieSubmodule.normalizer`. -/
def idealizer : LieIdeal R L where
  carrier := {x : L | ∀ m : M, ⁅x, m⁆ ∈ N}
  add_mem' := fun {x} {y} hx hy m ↦ by rw [add_lie]; 

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
x y : L
hx : x ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N}
hy : y ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N}
m : M
⊢ ⁅x, m⁆ + ⁅y, m⁆ ∈ N

Next tactic:
exact N.add_mem (hx m) (hy m)
/-- The idealizer of a Lie submodule.

See also `LieSubmodule.normalizer`. -/
def idealizer : LieIdeal R L where
  carrier := {x : L | ∀ m : M, ⁅x, m⁆ ∈ N}
  add_mem' := fun {x} {y} hx hy m ↦ by rw [add_lie]; exact N.add_mem (hx m) (hy m)
  zero_mem' := by 

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
⊢ 0 ∈
    { carrier := {x | ∀ (m : M), ⁅x, m⁆ ∈ N},
        add_mem' :=
          (_ :
            ∀ {x y : L},
              x ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} → y ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} → ∀ (m : M), ⁅x + y, m⁆ ∈ N) }.carrier

Next tactic:
simp
/-- The idealizer of a Lie submodule.

See also `LieSubmodule.normalizer`. -/
def idealizer : LieIdeal R L where
  carrier := {x : L | ∀ m : M, ⁅x, m⁆ ∈ N}
  add_mem' := fun {x} {y} hx hy m ↦ by rw [add_lie]; exact N.add_mem (hx m) (hy m)
  zero_mem' := by simp
  smul_mem' := fun t {x} hx m ↦ by 

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
t : R
x : L
hx :
  x ∈
    {
          toAddSubsemigroup :=
            { carrier := {x | ∀ (m : M), ⁅x, m⁆ ∈ N},
              add_mem' :=
                (_ :
                  ∀ {x y : L},
                    x ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} → y ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} → ∀ (m : M), ⁅x + y, m⁆ ∈ N) },
          zero_mem' := (_ : ∀ (a : M), ⁅0, a⁆ ∈ N) }.toAddSubsemigroup.carrier
m : M
⊢ ⁅t • x, m⁆ ∈ N

Next tactic:
rw [smul_lie]
/-- The idealizer of a Lie submodule.

See also `LieSubmodule.normalizer`. -/
def idealizer : LieIdeal R L where
  carrier := {x : L | ∀ m : M, ⁅x, m⁆ ∈ N}
  add_mem' := fun {x} {y} hx hy m ↦ by rw [add_lie]; exact N.add_mem (hx m) (hy m)
  zero_mem' := by simp
  smul_mem' := fun t {x} hx m ↦ by rw [smul_lie]; 

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
t : R
x : L
hx :
  x ∈
    {
          toAddSubsemigroup :=
            { carrier := {x | ∀ (m : M), ⁅x, m⁆ ∈ N},
              add_mem' :=
                (_ :
                  ∀ {x y : L},
                    x ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} → y ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} → ∀ (m : M), ⁅x + y, m⁆ ∈ N) },
          zero_mem' := (_ : ∀ (a : M), ⁅0, a⁆ ∈ N) }.toAddSubsemigroup.carrier
m : M
⊢ t • ⁅x, m⁆ ∈ N

Next tactic:
exact N.smul_mem t (hx m)
/-- The idealizer of a Lie submodule.

See also `LieSubmodule.normalizer`. -/
def idealizer : LieIdeal R L where
  carrier := {x : L | ∀ m : M, ⁅x, m⁆ ∈ N}
  add_mem' := fun {x} {y} hx hy m ↦ by rw [add_lie]; exact N.add_mem (hx m) (hy m)
  zero_mem' := by simp
  smul_mem' := fun t {x} hx m ↦ by rw [smul_lie]; exact N.smul_mem t (hx m)
  lie_mem := fun {x} {y} hy m ↦ by 

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
x y : L
hy :
  y ∈
    {
            toAddSubmonoid :=
              {
                toAddSubsemigroup :=
                  { carrier := {x | ∀ (m : M), ⁅x, m⁆ ∈ N},
                    add_mem' :=
                      (_ :
                        ∀ {x y : L},
                          x ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} →
                            y ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} → ∀ (m : M), ⁅x + y, m⁆ ∈ N) },
                zero_mem' := (_ : ∀ (a : M), ⁅0, a⁆ ∈ N) },
            smul_mem' :=
              (_ :
                ∀ (t : R) {x : L},
                  x ∈
                      {
                            toAddSubsemigroup :=
                              { carrier := {x | ∀ (m : M), ⁅x, m⁆ ∈ N},
                                add_mem' :=
                                  (_ :
                                    ∀ {x y : L},
                                      x ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} →
                                        y ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} → ∀ (m : M), ⁅x + y, m⁆ ∈ N) },
                            zero_mem' := (_ : ∀ (a : M), ⁅0, a⁆ ∈ N) }.toAddSubsemigroup.carrier →
                    ∀ (m : M), ⁅t • x, m⁆ ∈ N) }.toAddSubmonoid.toAddSubsemigroup.carrier
m : M
⊢ ⁅⁅x, y⁆, m⁆ ∈ N

Next tactic:
rw [lie_lie]
/-- The idealizer of a Lie submodule.

See also `LieSubmodule.normalizer`. -/
def idealizer : LieIdeal R L where
  carrier := {x : L | ∀ m : M, ⁅x, m⁆ ∈ N}
  add_mem' := fun {x} {y} hx hy m ↦ by rw [add_lie]; exact N.add_mem (hx m) (hy m)
  zero_mem' := by simp
  smul_mem' := fun t {x} hx m ↦ by rw [smul_lie]; exact N.smul_mem t (hx m)
  lie_mem := fun {x} {y} hy m ↦ by rw [lie_lie]; 

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
x y : L
hy :
  y ∈
    {
            toAddSubmonoid :=
              {
                toAddSubsemigroup :=
                  { carrier := {x | ∀ (m : M), ⁅x, m⁆ ∈ N},
                    add_mem' :=
                      (_ :
                        ∀ {x y : L},
                          x ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} →
                            y ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} → ∀ (m : M), ⁅x + y, m⁆ ∈ N) },
                zero_mem' := (_ : ∀ (a : M), ⁅0, a⁆ ∈ N) },
            smul_mem' :=
              (_ :
                ∀ (t : R) {x : L},
                  x ∈
                      {
                            toAddSubsemigroup :=
                              { carrier := {x | ∀ (m : M), ⁅x, m⁆ ∈ N},
                                add_mem' :=
                                  (_ :
                                    ∀ {x y : L},
                                      x ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} →
                                        y ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} → ∀ (m : M), ⁅x + y, m⁆ ∈ N) },
                            zero_mem' := (_ : ∀ (a : M), ⁅0, a⁆ ∈ N) }.toAddSubsemigroup.carrier →
                    ∀ (m : M), ⁅t • x, m⁆ ∈ N) }.toAddSubmonoid.toAddSubsemigroup.carrier
m : M
⊢ ⁅x, ⁅y, m⁆⁆ - ⁅y, ⁅x, m⁆⁆ ∈ N

Next tactic:
exact sub_mem (N.lie_mem (hy m)) (hy ⁅x, m⁆)
@[simp]
lemma _root_.LieIdeal.idealizer_eq_normalizer (I : LieIdeal R L) :
    I.idealizer = I.normalizer := by
  

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
I : LieIdeal R L
⊢ idealizer I = normalizer I

Next tactic:
ext x
@[simp]
lemma _root_.LieIdeal.idealizer_eq_normalizer (I : LieIdeal R L) :
    I.idealizer = I.normalizer := by
  ext x; 

Proof state:
case h
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
I : LieIdeal R L
x : L
⊢ x ∈ idealizer I ↔ x ∈ normalizer I

Next tactic:
exact forall_congr' fun y ↦ by simp only [← lie_skew x y, neg_mem_iff]
@[simp]
lemma _root_.LieIdeal.idealizer_eq_normalizer (I : LieIdeal R L) :
    I.idealizer = I.normalizer := by
  ext x; exact forall_congr' fun y ↦ by 

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
I : LieIdeal R L
x y : L
⊢ ⁅x, y⁆ ∈ I ↔ ⁅y, x⁆ ∈ I

Next tactic:
simp only [← lie_skew x y, neg_mem_iff]
/-- Regarding a Lie subalgebra `H ⊆ L` as a module over itself, its normalizer is in fact a Lie
subalgebra. -/
def normalizer : LieSubalgebra R L :=
  { H.toLieSubmodule.normalizer with
    lie_mem' := fun {y z} hy hz x => by
      

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
H : LieSubalgebra R L
src✝ : LieSubmodule R (↥H) L := LieSubmodule.normalizer (toLieSubmodule H)
y z : L
hy : y ∈ src✝.carrier
hz : z ∈ src✝.carrier
x : ↥H
⊢ ⁅x, ⁅y, z⁆⁆ ∈ toLieSubmodule H

Next tactic:
rw [coe_bracket_of_module, mem_toLieSubmodule, leibniz_lie, ← lie_skew y, ← sub_eq_add_neg]
/-- Regarding a Lie subalgebra `H ⊆ L` as a module over itself, its normalizer is in fact a Lie
subalgebra. -/
def normalizer : LieSubalgebra R L :=
  { H.toLieSubmodule.normalizer with
    lie_mem' := fun {y z} hy hz x => by
      rw [coe_bracket_of_module, mem_toLieSubmodule, leibniz_lie, ← lie_skew y, ← sub_eq_add_neg]
      

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
H : LieSubalgebra R L
src✝ : LieSubmodule R (↥H) L := LieSubmodule.normalizer (toLieSubmodule H)
y z : L
hy : y ∈ src✝.carrier
hz : z ∈ src✝.carrier
x : ↥H
⊢ ⁅⁅↑x, y⁆, z⁆ - ⁅⁅↑x, z⁆, y⁆ ∈ H

Next tactic:
exact H.sub_mem (hz ⟨_, hy x⟩) (hy ⟨_, hz x⟩)
theorem mem_normalizer_iff' (x : L) : x ∈ H.normalizer ↔ ∀ y : L, y ∈ H → ⁅y, x⁆ ∈ H := by
  

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
H : LieSubalgebra R L
x : L
⊢ x ∈ normalizer H ↔ ∀ y ∈ H, ⁅y, x⁆ ∈ H

Next tactic:
rw [Subtype.forall']
theorem mem_normalizer_iff' (x : L) : x ∈ H.normalizer ↔ ∀ y : L, y ∈ H → ⁅y, x⁆ ∈ H := by
  rw [Subtype.forall']; 

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
H : LieSubalgebra R L
x : L
⊢ x ∈ normalizer H ↔ ∀ (x_1 : ↥H), ⁅↑x_1, x⁆ ∈ H

Next tactic:
rfl
theorem mem_normalizer_iff (x : L) : x ∈ H.normalizer ↔ ∀ y : L, y ∈ H → ⁅x, y⁆ ∈ H := by
  

Proof state:
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
H : LieSubalgebra R L
x : L
⊢ x ∈ normalizer H ↔ ∀ y ∈ H, ⁅x, y⁆ ∈ H

Next tactic:
rw [mem_normalizer_iff']