l3lab/ntp-mathlib huggingface dataset:
theorem LieAlgebra.isEngelian_of_subsingleton [Subsingleton L] : LieAlgebra.IsEngelian R L := by
  intro M _i1 _i2 _i3 _i4 _h
  use 1
  suffices (⊤ : LieIdeal R L) = ⊥ by simp [this]
  haveI := (LieSubmodule.subsingleton_iff R L L).mpr inferInstance
  

Proof state:
case h
R : Type u₁
L : Type u₂
L₂ : Type u₃
M✝ : Type u₄
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
inst✝⁶ : LieRing L₂
inst✝⁵ : LieAlgebra R L₂
inst✝⁴ : AddCommGroup M✝
inst✝³ : Module R M✝
inst✝² : LieRingModule L M✝
inst✝¹ : LieModule R L M✝
inst✝ : Subsingleton L
M : Type u_1
_i1 : AddCommGroup M
_i2 : Module R M
_i3 : LieRingModule L M
_i4 : LieModule R L M
_h : ∀ (x : L), _root_.IsNilpotent ((toEndomorphism R L M) x)
this : Subsingleton (LieSubmodule R L L)
⊢ ⊤ = ⊥

Next tactic:
apply Subsingleton.elim
theorem Function.Surjective.isEngelian {f : L →ₗ⁅R⁆ L₂} (hf : Function.Surjective f)
    (h : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R L) : LieAlgebra.IsEngelian.{u₁, u₃, u₄} R L₂ := by
  

Proof state:
R : Type u₁
L : Type u₂
L₂ : Type u₃
M : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
f : L →ₗ⁅R⁆ L₂
hf : Surjective ⇑f
h : LieAlgebra.IsEngelian R L
⊢ LieAlgebra.IsEngelian R L₂

Next tactic:
intro M _i1 _i2 _i3 _i4 h'
theorem Function.Surjective.isEngelian {f : L →ₗ⁅R⁆ L₂} (hf : Function.Surjective f)
    (h : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R L) : LieAlgebra.IsEngelian.{u₁, u₃, u₄} R L₂ := by
  intro M _i1 _i2 _i3 _i4 h'
  

Proof state:
R : Type u₁
L : Type u₂
L₂ : Type u₃
M✝ : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M✝
inst✝² : Module R M✝
inst✝¹ : LieRingModule L M✝
inst✝ : LieModule R L M✝
f : L →ₗ⁅R⁆ L₂
hf : Surjective ⇑f
h : LieAlgebra.IsEngelian R L
M : Type u₄
_i1 : AddCommGroup M
_i2 : Module R M
_i3 : LieRingModule L₂ M
_i4 : LieModule R L₂ M
h' : ∀ (x : L₂), IsNilpotent ((toEndomorphism R L₂ M) x)
⊢ LieModule.IsNilpotent R L₂ M

Next tactic:
letI : LieRingModule L M := LieRingModule.compLieHom M f
theorem Function.Surjective.isEngelian {f : L →ₗ⁅R⁆ L₂} (hf : Function.Surjective f)
    (h : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R L) : LieAlgebra.IsEngelian.{u₁, u₃, u₄} R L₂ := by
  intro M _i1 _i2 _i3 _i4 h'
  letI : LieRingModule L M := LieRingModule.compLieHom M f
  

Proof state:
R : Type u₁
L : Type u₂
L₂ : Type u₃
M✝ : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M✝
inst✝² : Module R M✝
inst✝¹ : LieRingModule L M✝
inst✝ : LieModule R L M✝
f : L →ₗ⁅R⁆ L₂
hf : Surjective ⇑f
h : LieAlgebra.IsEngelian R L
M : Type u₄
_i1 : AddCommGroup M
_i2 : Module R M
_i3 : LieRingModule L₂ M
_i4 : LieModule R L₂ M
h' : ∀ (x : L₂), IsNilpotent ((toEndomorphism R L₂ M) x)
this : LieRingModule L M := LieRingModule.compLieHom M f
⊢ LieModule.IsNilpotent R L₂ M

Next tactic:
letI : LieModule R L M := compLieHom M f
theorem Function.Surjective.isEngelian {f : L →ₗ⁅R⁆ L₂} (hf : Function.Surjective f)
    (h : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R L) : LieAlgebra.IsEngelian.{u₁, u₃, u₄} R L₂ := by
  intro M _i1 _i2 _i3 _i4 h'
  letI : LieRingModule L M := LieRingModule.compLieHom M f
  letI : LieModule R L M := compLieHom M f
  

Proof state:
R : Type u₁
L : Type u₂
L₂ : Type u₃
M✝ : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M✝
inst✝² : Module R M✝
inst✝¹ : LieRingModule L M✝
inst✝ : LieModule R L M✝
f : L →ₗ⁅R⁆ L₂
hf : Surjective ⇑f
h : LieAlgebra.IsEngelian R L
M : Type u₄
_i1 : AddCommGroup M
_i2 : Module R M
_i3 : LieRingModule L₂ M
_i4 : LieModule R L₂ M
h' : ∀ (x : L₂), IsNilpotent ((toEndomorphism R L₂ M) x)
this✝ : LieRingModule L M := LieRingModule.compLieHom M f
this : LieModule R L M := compLieHom M f
⊢ LieModule.IsNilpotent R L₂ M

Next tactic:
have hnp : ∀ x, IsNilpotent (toEndomorphism R L M x) := fun x => h' (f x)
theorem Function.Surjective.isEngelian {f : L →ₗ⁅R⁆ L₂} (hf : Function.Surjective f)
    (h : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R L) : LieAlgebra.IsEngelian.{u₁, u₃, u₄} R L₂ := by
  intro M _i1 _i2 _i3 _i4 h'
  letI : LieRingModule L M := LieRingModule.compLieHom M f
  letI : LieModule R L M := compLieHom M f
  have hnp : ∀ x, IsNilpotent (toEndomorphism R L M x) := fun x => h' (f x)
  

Proof state:
R : Type u₁
L : Type u₂
L₂ : Type u₃
M✝ : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M✝
inst✝² : Module R M✝
inst✝¹ : LieRingModule L M✝
inst✝ : LieModule R L M✝
f : L →ₗ⁅R⁆ L₂
hf : Surjective ⇑f
h : LieAlgebra.IsEngelian R L
M : Type u₄
_i1 : AddCommGroup M
_i2 : Module R M
_i3 : LieRingModule L₂ M
_i4 : LieModule R L₂ M
h' : ∀ (x : L₂), IsNilpotent ((toEndomorphism R L₂ M) x)
this✝ : LieRingModule L M := LieRingModule.compLieHom M f
this : LieModule R L M := compLieHom M f
hnp : ∀ (x : L), IsNilpotent ((toEndomorphism R L M) x)
⊢ LieModule.IsNilpotent R L₂ M

Next tactic:
have surj_id : Function.Surjective (LinearMap.id : M →ₗ[R] M) := Function.surjective_id
theorem Function.Surjective.isEngelian {f : L →ₗ⁅R⁆ L₂} (hf : Function.Surjective f)
    (h : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R L) : LieAlgebra.IsEngelian.{u₁, u₃, u₄} R L₂ := by
  intro M _i1 _i2 _i3 _i4 h'
  letI : LieRingModule L M := LieRingModule.compLieHom M f
  letI : LieModule R L M := compLieHom M f
  have hnp : ∀ x, IsNilpotent (toEndomorphism R L M x) := fun x => h' (f x)
  have surj_id : Function.Surjective (LinearMap.id : M →ₗ[R] M) := Function.surjective_id
  

Proof state:
R : Type u₁
L : Type u₂
L₂ : Type u₃
M✝ : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M✝
inst✝² : Module R M✝
inst✝¹ : LieRingModule L M✝
inst✝ : LieModule R L M✝
f : L →ₗ⁅R⁆ L₂
hf : Surjective ⇑f
h : LieAlgebra.IsEngelian R L
M : Type u₄
_i1 : AddCommGroup M
_i2 : Module R M
_i3 : LieRingModule L₂ M
_i4 : LieModule R L₂ M
h' : ∀ (x : L₂), IsNilpotent ((toEndomorphism R L₂ M) x)
this✝ : LieRingModule L M := LieRingModule.compLieHom M f
this : LieModule R L M := compLieHom M f
hnp : ∀ (x : L), IsNilpotent ((toEndomorphism R L M) x)
surj_id : Surjective ⇑LinearMap.id
⊢ LieModule.IsNilpotent R L₂ M

Next tactic:
haveI : LieModule.IsNilpotent R L M := h M hnp
theorem Function.Surjective.isEngelian {f : L →ₗ⁅R⁆ L₂} (hf : Function.Surjective f)
    (h : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R L) : LieAlgebra.IsEngelian.{u₁, u₃, u₄} R L₂ := by
  intro M _i1 _i2 _i3 _i4 h'
  letI : LieRingModule L M := LieRingModule.compLieHom M f
  letI : LieModule R L M := compLieHom M f
  have hnp : ∀ x, IsNilpotent (toEndomorphism R L M x) := fun x => h' (f x)
  have surj_id : Function.Surjective (LinearMap.id : M →ₗ[R] M) := Function.surjective_id
  haveI : LieModule.IsNilpotent R L M := h M hnp
  

Proof state:
R : Type u₁
L : Type u₂
L₂ : Type u₃
M✝ : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M✝
inst✝² : Module R M✝
inst✝¹ : LieRingModule L M✝
inst✝ : LieModule R L M✝
f : L →ₗ⁅R⁆ L₂
hf : Surjective ⇑f
h : LieAlgebra.IsEngelian R L
M : Type u₄
_i1 : AddCommGroup M
_i2 : Module R M
_i3 : LieRingModule L₂ M
_i4 : LieModule R L₂ M
h' : ∀ (x : L₂), IsNilpotent ((toEndomorphism R L₂ M) x)
this✝¹ : LieRingModule L M := LieRingModule.compLieHom M f
this✝ : LieModule R L M := compLieHom M f
hnp : ∀ (x : L), IsNilpotent ((toEndomorphism R L M) x)
surj_id : Surjective ⇑LinearMap.id
this : LieModule.IsNilpotent R L M
⊢ LieModule.IsNilpotent R L₂ M

Next tactic:
apply hf.lieModuleIsNilpotent surj_id
theorem Function.Surjective.isEngelian {f : L →ₗ⁅R⁆ L₂} (hf : Function.Surjective f)
    (h : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R L) : LieAlgebra.IsEngelian.{u₁, u₃, u₄} R L₂ := by
  intro M _i1 _i2 _i3 _i4 h'
  letI : LieRingModule L M := LieRingModule.compLieHom M f
  letI : LieModule R L M := compLieHom M f
  have hnp : ∀ x, IsNilpotent (toEndomorphism R L M x) := fun x => h' (f x)
  have surj_id : Function.Surjective (LinearMap.id : M →ₗ[R] M) := Function.surjective_id
  haveI : LieModule.IsNilpotent R L M := h M hnp
  apply hf.lieModuleIsNilpotent surj_id
  -- Porting note: was `simp`
  

Proof state:
case hfg
R : Type u₁
L : Type u₂
L₂ : Type u₃
M✝ : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M✝
inst✝² : Module R M✝
inst✝¹ : LieRingModule L M✝
inst✝ : LieModule R L M✝
f : L →ₗ⁅R⁆ L₂
hf : Surjective ⇑f
h : LieAlgebra.IsEngelian R L
M : Type u₄
_i1 : AddCommGroup M
_i2 : Module R M
_i3 : LieRingModule L₂ M
_i4 : LieModule R L₂ M
h' : ∀ (x : L₂), IsNilpotent ((toEndomorphism R L₂ M) x)
this✝¹ : LieRingModule L M := LieRingModule.compLieHom M f
this✝ : LieModule R L M := compLieHom M f
hnp : ∀ (x : L), IsNilpotent ((toEndomorphism R L M) x)
surj_id : Surjective ⇑LinearMap.id
this : LieModule.IsNilpotent R L M
⊢ ∀ (x : L) (m : M), ⁅f x, LinearMap.id m⁆ = LinearMap.id ⁅x, m⁆

Next tactic:
intros
theorem Function.Surjective.isEngelian {f : L →ₗ⁅R⁆ L₂} (hf : Function.Surjective f)
    (h : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R L) : LieAlgebra.IsEngelian.{u₁, u₃, u₄} R L₂ := by
  intro M _i1 _i2 _i3 _i4 h'
  letI : LieRingModule L M := LieRingModule.compLieHom M f
  letI : LieModule R L M := compLieHom M f
  have hnp : ∀ x, IsNilpotent (toEndomorphism R L M x) := fun x => h' (f x)
  have surj_id : Function.Surjective (LinearMap.id : M →ₗ[R] M) := Function.surjective_id
  haveI : LieModule.IsNilpotent R L M := h M hnp
  apply hf.lieModuleIsNilpotent surj_id
  -- Porting note: was `simp`
  intros; 

Proof state:
case hfg
R : Type u₁
L : Type u₂
L₂ : Type u₃
M✝ : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M✝
inst✝² : Module R M✝
inst✝¹ : LieRingModule L M✝
inst✝ : LieModule R L M✝
f : L →ₗ⁅R⁆ L₂
hf : Surjective ⇑f
h : LieAlgebra.IsEngelian R L
M : Type u₄
_i1 : AddCommGroup M
_i2 : Module R M
_i3 : LieRingModule L₂ M
_i4 : LieModule R L₂ M
h' : ∀ (x : L₂), IsNilpotent ((toEndomorphism R L₂ M) x)
this✝¹ : LieRingModule L M := LieRingModule.compLieHom M f
this✝ : LieModule R L M := compLieHom M f
hnp : ∀ (x : L), IsNilpotent ((toEndomorphism R L M) x)
surj_id : Surjective ⇑LinearMap.id
this : LieModule.IsNilpotent R L M
x✝ : L
m✝ : M
⊢ ⁅f x✝, LinearMap.id m✝⁆ = LinearMap.id ⁅x✝, m✝⁆

Next tactic:
simp only [LinearMap.id_coe, id_eq]
theorem Function.Surjective.isEngelian {f : L →ₗ⁅R⁆ L₂} (hf : Function.Surjective f)
    (h : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R L) : LieAlgebra.IsEngelian.{u₁, u₃, u₄} R L₂ := by
  intro M _i1 _i2 _i3 _i4 h'
  letI : LieRingModule L M := LieRingModule.compLieHom M f
  letI : LieModule R L M := compLieHom M f
  have hnp : ∀ x, IsNilpotent (toEndomorphism R L M x) := fun x => h' (f x)
  have surj_id : Function.Surjective (LinearMap.id : M →ₗ[R] M) := Function.surjective_id
  haveI : LieModule.IsNilpotent R L M := h M hnp
  apply hf.lieModuleIsNilpotent surj_id
  -- Porting note: was `simp`
  intros; simp only [LinearMap.id_coe, id_eq]; 

Proof state:
case hfg
R : Type u₁
L : Type u₂
L₂ : Type u₃
M✝ : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M✝
inst✝² : Module R M✝
inst✝¹ : LieRingModule L M✝
inst✝ : LieModule R L M✝
f : L →ₗ⁅R⁆ L₂
hf : Surjective ⇑f
h : LieAlgebra.IsEngelian R L
M : Type u₄
_i1 : AddCommGroup M
_i2 : Module R M
_i3 : LieRingModule L₂ M
_i4 : LieModule R L₂ M
h' : ∀ (x : L₂), IsNilpotent ((toEndomorphism R L₂ M) x)
this✝¹ : LieRingModule L M := LieRingModule.compLieHom M f
this✝ : LieModule R L M := compLieHom M f
hnp : ∀ (x : L), IsNilpotent ((toEndomorphism R L M) x)
surj_id : Surjective ⇑LinearMap.id
this : LieModule.IsNilpotent R L M
x✝ : L
m✝ : M
⊢ ⁅f x✝, m✝⁆ = ⁅x✝, m✝⁆

Next tactic:
rfl
theorem LieAlgebra.exists_engelian_lieSubalgebra_of_lt_normalizer {K : LieSubalgebra R L}
    (hK₁ : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K) (hK₂ : K < K.normalizer) :
    ∃ (K' : LieSubalgebra R L), LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K' ∧ K < K' := by
  

Proof state:
R : Type u₁
L : Type u₂
L₂ : Type u₃
M : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K : LieSubalgebra R L
hK₁ : IsEngelian R ↥K
hK₂ : K < LieSubalgebra.normalizer K
⊢ ∃ K', IsEngelian R ↥K' ∧ K < K'

Next tactic:
obtain ⟨x, hx₁, hx₂⟩ := SetLike.exists_of_lt hK₂
theorem LieAlgebra.exists_engelian_lieSubalgebra_of_lt_normalizer {K : LieSubalgebra R L}
    (hK₁ : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K) (hK₂ : K < K.normalizer) :
    ∃ (K' : LieSubalgebra R L), LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K' ∧ K < K' := by
  obtain ⟨x, hx₁, hx₂⟩ := SetLike.exists_of_lt hK₂
  

Proof state:
case intro.intro
R : Type u₁
L : Type u₂
L₂ : Type u₃
M : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K : LieSubalgebra R L
hK₁ : IsEngelian R ↥K
hK₂ : K < LieSubalgebra.normalizer K
x : L
hx₁ : x ∈ LieSubalgebra.normalizer K
hx₂ : x ∉ K
⊢ ∃ K', IsEngelian R ↥K' ∧ K < K'

Next tactic:
let K' : LieSubalgebra R L :=
    { (R ∙ x) ⊔ (K : Submodule R L) with
      lie_mem' := fun {y z} => LieSubalgebra.lie_mem_sup_of_mem_normalizer hx₁ }
theorem LieAlgebra.exists_engelian_lieSubalgebra_of_lt_normalizer {K : LieSubalgebra R L}
    (hK₁ : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K) (hK₂ : K < K.normalizer) :
    ∃ (K' : LieSubalgebra R L), LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K' ∧ K < K' := by
  obtain ⟨x, hx₁, hx₂⟩ := SetLike.exists_of_lt hK₂
  let K' : LieSubalgebra R L :=
    { (R ∙ x) ⊔ (K : Submodule R L) with
      lie_mem' := fun {y z} => LieSubalgebra.lie_mem_sup_of_mem_normalizer hx₁ }
  

Proof state:
case intro.intro
R : Type u₁
L : Type u₂
L₂ : Type u₃
M : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K : LieSubalgebra R L
hK₁ : IsEngelian R ↥K
hK₂ : K < LieSubalgebra.normalizer K
x : L
hx₁ : x ∈ LieSubalgebra.normalizer K
hx₂ : x ∉ K
K' : LieSubalgebra R L :=
  let src := Submodule.span R {x} ⊔ K.toSubmodule;
  {
    toSubmodule :=
      { toAddSubmonoid := src.toAddSubmonoid,
        smul_mem' := (_ : ∀ (c : R) {x : L}, x ∈ src.carrier → c • x ∈ src.carrier) },
    lie_mem' :=
      (_ :
        ∀ {y z : L},
          y ∈ Submodule.span R {x} ⊔ K.toSubmodule →
            z ∈ Submodule.span R {x} ⊔ K.toSubmodule → ⁅y, z⁆ ∈ Submodule.span R {x} ⊔ K.toSubmodule) }
⊢ ∃ K', IsEngelian R ↥K' ∧ K < K'

Next tactic:
have hxK' : x ∈ K' := Submodule.mem_sup_left (Submodule.subset_span (Set.mem_singleton _))
theorem LieAlgebra.exists_engelian_lieSubalgebra_of_lt_normalizer {K : LieSubalgebra R L}
    (hK₁ : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K) (hK₂ : K < K.normalizer) :
    ∃ (K' : LieSubalgebra R L), LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K' ∧ K < K' := by
  obtain ⟨x, hx₁, hx₂⟩ := SetLike.exists_of_lt hK₂
  let K' : LieSubalgebra R L :=
    { (R ∙ x) ⊔ (K : Submodule R L) with
      lie_mem' := fun {y z} => LieSubalgebra.lie_mem_sup_of_mem_normalizer hx₁ }
  have hxK' : x ∈ K' := Submodule.mem_sup_left (Submodule.subset_span (Set.mem_singleton _))
  

Proof state:
case intro.intro
R : Type u₁
L : Type u₂
L₂ : Type u₃
M : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K : LieSubalgebra R L
hK₁ : IsEngelian R ↥K
hK₂ : K < LieSubalgebra.normalizer K
x : L
hx₁ : x ∈ LieSubalgebra.normalizer K
hx₂ : x ∉ K
K' : LieSubalgebra R L :=
  let src := Submodule.span R {x} ⊔ K.toSubmodule;
  {
    toSubmodule :=
      { toAddSubmonoid := src.toAddSubmonoid,
        smul_mem' := (_ : ∀ (c : R) {x : L}, x ∈ src.carrier → c • x ∈ src.carrier) },
    lie_mem' :=
      (_ :
        ∀ {y z : L},
          y ∈ Submodule.span R {x} ⊔ K.toSubmodule →
            z ∈ Submodule.span R {x} ⊔ K.toSubmodule → ⁅y, z⁆ ∈ Submodule.span R {x} ⊔ K.toSubmodule) }
hxK' : x ∈ K'
⊢ ∃ K', IsEngelian R ↥K' ∧ K < K'

Next tactic:
have hKK' : K ≤ K' := (LieSubalgebra.coe_submodule_le_coe_submodule K K').mp le_sup_right
theorem LieAlgebra.exists_engelian_lieSubalgebra_of_lt_normalizer {K : LieSubalgebra R L}
    (hK₁ : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K) (hK₂ : K < K.normalizer) :
    ∃ (K' : LieSubalgebra R L), LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K' ∧ K < K' := by
  obtain ⟨x, hx₁, hx₂⟩ := SetLike.exists_of_lt hK₂
  let K' : LieSubalgebra R L :=
    { (R ∙ x) ⊔ (K : Submodule R L) with
      lie_mem' := fun {y z} => LieSubalgebra.lie_mem_sup_of_mem_normalizer hx₁ }
  have hxK' : x ∈ K' := Submodule.mem_sup_left (Submodule.subset_span (Set.mem_singleton _))
  have hKK' : K ≤ K' := (LieSubalgebra.coe_submodule_le_coe_submodule K K').mp le_sup_right
  

Proof state:
case intro.intro
R : Type u₁
L : Type u₂
L₂ : Type u₃
M : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K : LieSubalgebra R L
hK₁ : IsEngelian R ↥K
hK₂ : K < LieSubalgebra.normalizer K
x : L
hx₁ : x ∈ LieSubalgebra.normalizer K
hx₂ : x ∉ K
K' : LieSubalgebra R L :=
  let src := Submodule.span R {x} ⊔ K.toSubmodule;
  {
    toSubmodule :=
      { toAddSubmonoid := src.toAddSubmonoid,
        smul_mem' := (_ : ∀ (c : R) {x : L}, x ∈ src.carrier → c • x ∈ src.carrier) },
    lie_mem' :=
      (_ :
        ∀ {y z : L},
          y ∈ Submodule.span R {x} ⊔ K.toSubmodule →
            z ∈ Submodule.span R {x} ⊔ K.toSubmodule → ⁅y, z⁆ ∈ Submodule.span R {x} ⊔ K.toSubmodule) }
hxK' : x ∈ K'
hKK' : K ≤ K'
⊢ ∃ K', IsEngelian R ↥K' ∧ K < K'

Next tactic:
have hK' : K' ≤ K.normalizer := by
    rw [← LieSubalgebra.coe_submodule_le_coe_submodule]
    exact sup_le ((Submodule.span_singleton_le_iff_mem _ _).mpr hx₁) hK₂.le
theorem LieAlgebra.exists_engelian_lieSubalgebra_of_lt_normalizer {K : LieSubalgebra R L}
    (hK₁ : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K) (hK₂ : K < K.normalizer) :
    ∃ (K' : LieSubalgebra R L), LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K' ∧ K < K' := by
  obtain ⟨x, hx₁, hx₂⟩ := SetLike.exists_of_lt hK₂
  let K' : LieSubalgebra R L :=
    { (R ∙ x) ⊔ (K : Submodule R L) with
      lie_mem' := fun {y z} => LieSubalgebra.lie_mem_sup_of_mem_normalizer hx₁ }
  have hxK' : x ∈ K' := Submodule.mem_sup_left (Submodule.subset_span (Set.mem_singleton _))
  have hKK' : K ≤ K' := (LieSubalgebra.coe_submodule_le_coe_submodule K K').mp le_sup_right
  have hK' : K' ≤ K.normalizer := by
    

Proof state:
R : Type u₁
L : Type u₂
L₂ : Type u₃
M : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K : LieSubalgebra R L
hK₁ : IsEngelian R ↥K
hK₂ : K < LieSubalgebra.normalizer K
x : L
hx₁ : x ∈ LieSubalgebra.normalizer K
hx₂ : x ∉ K
K' : LieSubalgebra R L :=
  let src := Submodule.span R {x} ⊔ K.toSubmodule;
  {
    toSubmodule :=
      { toAddSubmonoid := src.toAddSubmonoid,
        smul_mem' := (_ : ∀ (c : R) {x : L}, x ∈ src.carrier → c • x ∈ src.carrier) },
    lie_mem' :=
      (_ :
        ∀ {y z : L},
          y ∈ Submodule.span R {x} ⊔ K.toSubmodule →
            z ∈ Submodule.span R {x} ⊔ K.toSubmodule → ⁅y, z⁆ ∈ Submodule.span R {x} ⊔ K.toSubmodule) }
hxK' : x ∈ K'
hKK' : K ≤ K'
⊢ K' ≤ LieSubalgebra.normalizer K

Next tactic:
rw [← LieSubalgebra.coe_submodule_le_coe_submodule]
theorem LieAlgebra.exists_engelian_lieSubalgebra_of_lt_normalizer {K : LieSubalgebra R L}
    (hK₁ : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K) (hK₂ : K < K.normalizer) :
    ∃ (K' : LieSubalgebra R L), LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K' ∧ K < K' := by
  obtain ⟨x, hx₁, hx₂⟩ := SetLike.exists_of_lt hK₂
  let K' : LieSubalgebra R L :=
    { (R ∙ x) ⊔ (K : Submodule R L) with
      lie_mem' := fun {y z} => LieSubalgebra.lie_mem_sup_of_mem_normalizer hx₁ }
  have hxK' : x ∈ K' := Submodule.mem_sup_left (Submodule.subset_span (Set.mem_singleton _))
  have hKK' : K ≤ K' := (LieSubalgebra.coe_submodule_le_coe_submodule K K').mp le_sup_right
  have hK' : K' ≤ K.normalizer := by
    rw [← LieSubalgebra.coe_submodule_le_coe_submodule]
    

Proof state:
R : Type u₁
L : Type u₂
L₂ : Type u₃
M : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K : LieSubalgebra R L
hK₁ : IsEngelian R ↥K
hK₂ : K < LieSubalgebra.normalizer K
x : L
hx₁ : x ∈ LieSubalgebra.normalizer K
hx₂ : x ∉ K
K' : LieSubalgebra R L :=
  let src := Submodule.span R {x} ⊔ K.toSubmodule;
  {
    toSubmodule :=
      { toAddSubmonoid := src.toAddSubmonoid,
        smul_mem' := (_ : ∀ (c : R) {x : L}, x ∈ src.carrier → c • x ∈ src.carrier) },
    lie_mem' :=
      (_ :
        ∀ {y z : L},
          y ∈ Submodule.span R {x} ⊔ K.toSubmodule →
            z ∈ Submodule.span R {x} ⊔ K.toSubmodule → ⁅y, z⁆ ∈ Submodule.span R {x} ⊔ K.toSubmodule) }
hxK' : x ∈ K'
hKK' : K ≤ K'
⊢ K'.toSubmodule ≤ (LieSubalgebra.normalizer K).toSubmodule

Next tactic:
exact sup_le ((Submodule.span_singleton_le_iff_mem _ _).mpr hx₁) hK₂.le
theorem LieAlgebra.exists_engelian_lieSubalgebra_of_lt_normalizer {K : LieSubalgebra R L}
    (hK₁ : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K) (hK₂ : K < K.normalizer) :
    ∃ (K' : LieSubalgebra R L), LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K' ∧ K < K' := by
  obtain ⟨x, hx₁, hx₂⟩ := SetLike.exists_of_lt hK₂
  let K' : LieSubalgebra R L :=
    { (R ∙ x) ⊔ (K : Submodule R L) with
      lie_mem' := fun {y z} => LieSubalgebra.lie_mem_sup_of_mem_normalizer hx₁ }
  have hxK' : x ∈ K' := Submodule.mem_sup_left (Submodule.subset_span (Set.mem_singleton _))
  have hKK' : K ≤ K' := (LieSubalgebra.coe_submodule_le_coe_submodule K K').mp le_sup_right
  have hK' : K' ≤ K.normalizer := by
    rw [← LieSubalgebra.coe_submodule_le_coe_submodule]
    exact sup_le ((Submodule.span_singleton_le_iff_mem _ _).mpr hx₁) hK₂.le
  

Proof state:
case intro.intro
R : Type u₁
L : Type u₂
L₂ : Type u₃
M : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K : LieSubalgebra R L
hK₁ : IsEngelian R ↥K
hK₂ : K < LieSubalgebra.normalizer K
x : L
hx₁ : x ∈ LieSubalgebra.normalizer K
hx₂ : x ∉ K
K' : LieSubalgebra R L :=
  let src := Submodule.span R {x} ⊔ K.toSubmodule;
  {
    toSubmodule :=
      { toAddSubmonoid := src.toAddSubmonoid,
        smul_mem' := (_ : ∀ (c : R) {x : L}, x ∈ src.carrier → c • x ∈ src.carrier) },
    lie_mem' :=
      (_ :
        ∀ {y z : L},
          y ∈ Submodule.span R {x} ⊔ K.toSubmodule →
            z ∈ Submodule.span R {x} ⊔ K.toSubmodule → ⁅y, z⁆ ∈ Submodule.span R {x} ⊔ K.toSubmodule) }
hxK' : x ∈ K'
hKK' : K ≤ K'
hK' : K' ≤ LieSubalgebra.normalizer K
⊢ ∃ K', IsEngelian R ↥K' ∧ K < K'

Next tactic:
refine' ⟨K', _, lt_iff_le_and_ne.mpr ⟨hKK', fun contra => hx₂ (contra.symm ▸ hxK')⟩⟩