l3lab/ntp-mathlib huggingface dataset:
@[simp]
theorem ideal_oper_maxTrivSubmodule_eq_bot (I : LieIdeal R L) :
    ⁅I, maxTrivSubmodule R L M⁆ = ⊥ := by
  rw [← LieSubmodule.coe_toSubmodule_eq_iff, LieSubmodule.lieIdeal_oper_eq_linear_span,
    LieSubmodule.bot_coeSubmodule, Submodule.span_eq_bot]
  rintro m ⟨⟨x, hx⟩, ⟨⟨m, hm⟩, rfl⟩⟩
  

Proof state:
case intro.mk.intro.mk
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
I : LieIdeal R L
x : L
hx : x ∈ I
m : M
hm : m ∈ maxTrivSubmodule R L M
⊢ ⁅↑{ val := x, property := hx }, ↑{ val := m, property := hm }⁆ = 0

Next tactic:
exact hm x
theorem le_max_triv_iff_bracket_eq_bot {N : LieSubmodule R L M} :
    N ≤ maxTrivSubmodule R L M ↔ ⁅(⊤ : LieIdeal R L), N⁆ = ⊥ := by
  

Proof state:
R : Type u
L : Type v
M : Type w
N✝ : Type w₁
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 N✝
inst✝² : Module R N✝
inst✝¹ : LieRingModule L N✝
inst✝ : LieModule R L N✝
N : LieSubmodule R L M
⊢ N ≤ maxTrivSubmodule R L M ↔ ⁅⊤, N⁆ = ⊥

Next tactic:
refine' ⟨fun h => _, fun h m hm => _⟩
theorem le_max_triv_iff_bracket_eq_bot {N : LieSubmodule R L M} :
    N ≤ maxTrivSubmodule R L M ↔ ⁅(⊤ : LieIdeal R L), N⁆ = ⊥ := by
  refine' ⟨fun h => _, fun h m hm => _⟩
  · 

Proof state:
case refine'_1
R : Type u
L : Type v
M : Type w
N✝ : Type w₁
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 N✝
inst✝² : Module R N✝
inst✝¹ : LieRingModule L N✝
inst✝ : LieModule R L N✝
N : LieSubmodule R L M
h : N ≤ maxTrivSubmodule R L M
⊢ ⁅⊤, N⁆ = ⊥

Next tactic:
rw [← le_bot_iff, ← ideal_oper_maxTrivSubmodule_eq_bot R L M ⊤]
theorem le_max_triv_iff_bracket_eq_bot {N : LieSubmodule R L M} :
    N ≤ maxTrivSubmodule R L M ↔ ⁅(⊤ : LieIdeal R L), N⁆ = ⊥ := by
  refine' ⟨fun h => _, fun h m hm => _⟩
  · rw [← le_bot_iff, ← ideal_oper_maxTrivSubmodule_eq_bot R L M ⊤]
    

Proof state:
case refine'_1
R : Type u
L : Type v
M : Type w
N✝ : Type w₁
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 N✝
inst✝² : Module R N✝
inst✝¹ : LieRingModule L N✝
inst✝ : LieModule R L N✝
N : LieSubmodule R L M
h : N ≤ maxTrivSubmodule R L M
⊢ ⁅⊤, N⁆ ≤ ⁅⊤, maxTrivSubmodule R L M⁆

Next tactic:
exact LieSubmodule.mono_lie_right _ _ ⊤ h
theorem le_max_triv_iff_bracket_eq_bot {N : LieSubmodule R L M} :
    N ≤ maxTrivSubmodule R L M ↔ ⁅(⊤ : LieIdeal R L), N⁆ = ⊥ := by
  refine' ⟨fun h => _, fun h m hm => _⟩
  · rw [← le_bot_iff, ← ideal_oper_maxTrivSubmodule_eq_bot R L M ⊤]
    exact LieSubmodule.mono_lie_right _ _ ⊤ h
  · 

Proof state:
case refine'_2
R : Type u
L : Type v
M : Type w
N✝ : Type w₁
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 N✝
inst✝² : Module R N✝
inst✝¹ : LieRingModule L N✝
inst✝ : LieModule R L N✝
N : LieSubmodule R L M
h : ⁅⊤, N⁆ = ⊥
m : M
hm : m ∈ N
⊢ m ∈ maxTrivSubmodule R L M

Next tactic:
rw [mem_maxTrivSubmodule]
theorem le_max_triv_iff_bracket_eq_bot {N : LieSubmodule R L M} :
    N ≤ maxTrivSubmodule R L M ↔ ⁅(⊤ : LieIdeal R L), N⁆ = ⊥ := by
  refine' ⟨fun h => _, fun h m hm => _⟩
  · rw [← le_bot_iff, ← ideal_oper_maxTrivSubmodule_eq_bot R L M ⊤]
    exact LieSubmodule.mono_lie_right _ _ ⊤ h
  · rw [mem_maxTrivSubmodule]
    

Proof state:
case refine'_2
R : Type u
L : Type v
M : Type w
N✝ : Type w₁
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 N✝
inst✝² : Module R N✝
inst✝¹ : LieRingModule L N✝
inst✝ : LieModule R L N✝
N : LieSubmodule R L M
h : ⁅⊤, N⁆ = ⊥
m : M
hm : m ∈ N
⊢ ∀ (x : L), ⁅x, m⁆ = 0

Next tactic:
rw [LieSubmodule.lie_eq_bot_iff] at h
theorem le_max_triv_iff_bracket_eq_bot {N : LieSubmodule R L M} :
    N ≤ maxTrivSubmodule R L M ↔ ⁅(⊤ : LieIdeal R L), N⁆ = ⊥ := by
  refine' ⟨fun h => _, fun h m hm => _⟩
  · rw [← le_bot_iff, ← ideal_oper_maxTrivSubmodule_eq_bot R L M ⊤]
    exact LieSubmodule.mono_lie_right _ _ ⊤ h
  · rw [mem_maxTrivSubmodule]
    rw [LieSubmodule.lie_eq_bot_iff] at h
    

Proof state:
case refine'_2
R : Type u
L : Type v
M : Type w
N✝ : Type w₁
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 N✝
inst✝² : Module R N✝
inst✝¹ : LieRingModule L N✝
inst✝ : LieModule R L N✝
N : LieSubmodule R L M
h : ∀ x ∈ ⊤, ∀ m ∈ N, ⁅x, m⁆ = 0
m : M
hm : m ∈ N
⊢ ∀ (x : L), ⁅x, m⁆ = 0

Next tactic:
exact fun x => h x (LieSubmodule.mem_top x) m hm
theorem isTrivial_iff_max_triv_eq_top : IsTrivial L M ↔ maxTrivSubmodule R L M = ⊤ := by
  

Proof state:
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
⊢ IsTrivial L M ↔ maxTrivSubmodule R L M = ⊤

Next tactic:
constructor
theorem isTrivial_iff_max_triv_eq_top : IsTrivial L M ↔ maxTrivSubmodule R L M = ⊤ := by
  constructor
  · 

Proof state:
case mp
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
⊢ IsTrivial L M → maxTrivSubmodule R L M = ⊤

Next tactic:
rintro ⟨h⟩
theorem isTrivial_iff_max_triv_eq_top : IsTrivial L M ↔ maxTrivSubmodule R L M = ⊤ := by
  constructor
  · rintro ⟨h⟩; 

Proof state:
case mp.mk
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
h : ∀ (x : L) (m : M), ⁅x, m⁆ = 0
⊢ maxTrivSubmodule R L M = ⊤

Next tactic:
ext
theorem isTrivial_iff_max_triv_eq_top : IsTrivial L M ↔ maxTrivSubmodule R L M = ⊤ := by
  constructor
  · rintro ⟨h⟩; ext; 

Proof state:
case mp.mk.h
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
h : ∀ (x : L) (m : M), ⁅x, m⁆ = 0
m✝ : M
⊢ m✝ ∈ maxTrivSubmodule R L M ↔ m✝ ∈ ⊤

Next tactic:
simp only [mem_maxTrivSubmodule, h, forall_const, LieSubmodule.mem_top]
theorem isTrivial_iff_max_triv_eq_top : IsTrivial L M ↔ maxTrivSubmodule R L M = ⊤ := by
  constructor
  · rintro ⟨h⟩; ext; simp only [mem_maxTrivSubmodule, h, forall_const, LieSubmodule.mem_top]
  · 

Proof state:
case mpr
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
⊢ maxTrivSubmodule R L M = ⊤ → IsTrivial L M

Next tactic:
intro h
theorem isTrivial_iff_max_triv_eq_top : IsTrivial L M ↔ maxTrivSubmodule R L M = ⊤ := by
  constructor
  · rintro ⟨h⟩; ext; simp only [mem_maxTrivSubmodule, h, forall_const, LieSubmodule.mem_top]
  · intro h; 

Proof state:
case mpr
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
h : maxTrivSubmodule R L M = ⊤
⊢ IsTrivial L M

Next tactic:
constructor
theorem isTrivial_iff_max_triv_eq_top : IsTrivial L M ↔ maxTrivSubmodule R L M = ⊤ := by
  constructor
  · rintro ⟨h⟩; ext; simp only [mem_maxTrivSubmodule, h, forall_const, LieSubmodule.mem_top]
  · intro h; constructor; 

Proof state:
case mpr.trivial
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
h : maxTrivSubmodule R L M = ⊤
⊢ ∀ (x : L) (m : M), ⁅x, m⁆ = 0

Next tactic:
intro x m
theorem isTrivial_iff_max_triv_eq_top : IsTrivial L M ↔ maxTrivSubmodule R L M = ⊤ := by
  constructor
  · rintro ⟨h⟩; ext; simp only [mem_maxTrivSubmodule, h, forall_const, LieSubmodule.mem_top]
  · intro h; constructor; intro x m; 

Proof state:
case mpr.trivial
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
h : maxTrivSubmodule R L M = ⊤
x : L
m : M
⊢ ⁅x, m⁆ = 0

Next tactic:
revert x
theorem isTrivial_iff_max_triv_eq_top : IsTrivial L M ↔ maxTrivSubmodule R L M = ⊤ := by
  constructor
  · rintro ⟨h⟩; ext; simp only [mem_maxTrivSubmodule, h, forall_const, LieSubmodule.mem_top]
  · intro h; constructor; intro x m; revert x
    

Proof state:
case mpr.trivial
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
h : maxTrivSubmodule R L M = ⊤
m : M
⊢ ∀ (x : L), ⁅x, m⁆ = 0

Next tactic:
rw [← mem_maxTrivSubmodule R L M, h]
theorem isTrivial_iff_max_triv_eq_top : IsTrivial L M ↔ maxTrivSubmodule R L M = ⊤ := by
  constructor
  · rintro ⟨h⟩; ext; simp only [mem_maxTrivSubmodule, h, forall_const, LieSubmodule.mem_top]
  · intro h; constructor; intro x m; revert x
    rw [← mem_maxTrivSubmodule R L M, h]; 

Proof state:
case mpr.trivial
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
h : maxTrivSubmodule R L M = ⊤
m : M
⊢ m ∈ ⊤

Next tactic:
exact LieSubmodule.mem_top m
/-- `maxTrivSubmodule` is functorial. -/
def maxTrivHom (f : M →ₗ⁅R,L⁆ N) : maxTrivSubmodule R L M →ₗ⁅R,L⁆ maxTrivSubmodule R L N where
  toFun m := ⟨f m, fun x =>
    (LieModuleHom.map_lie _ _ _).symm.trans <|
      (congr_arg f (m.property x)).trans (LieModuleHom.map_zero _)⟩
  map_add' m n := by 

Proof state:
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : M →ₗ⁅R,L⁆ N
m n : ↥↑(maxTrivSubmodule R L M)
⊢ (fun m => { val := f ↑m, property := (_ : ∀ (x : L), ⁅x, f ↑m⁆ = 0) }) (m + n) =
    (fun m => { val := f ↑m, property := (_ : ∀ (x : L), ⁅x, f ↑m⁆ = 0) }) m +
      (fun m => { val := f ↑m, property := (_ : ∀ (x : L), ⁅x, f ↑m⁆ = 0) }) n

Next tactic:
simp [Function.comp_apply]
/-- `maxTrivSubmodule` is functorial. -/
def maxTrivHom (f : M →ₗ⁅R,L⁆ N) : maxTrivSubmodule R L M →ₗ⁅R,L⁆ maxTrivSubmodule R L N where
  toFun m := ⟨f m, fun x =>
    (LieModuleHom.map_lie _ _ _).symm.trans <|
      (congr_arg f (m.property x)).trans (LieModuleHom.map_zero _)⟩
  map_add' m n := by simp [Function.comp_apply]; 

Proof state:
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : M →ₗ⁅R,L⁆ N
m n : ↥↑(maxTrivSubmodule R L M)
⊢ { val := f ↑m + f ↑n, property := (_ : (fun x => x ∈ ↑(maxTrivSubmodule R L N)) (f ↑m + f ↑n)) } =
    { val := f ↑m, property := (_ : ∀ (x : L), ⁅x, f ↑m⁆ = 0) } +
      { val := f ↑n, property := (_ : ∀ (x : L), ⁅x, f ↑n⁆ = 0) }

Next tactic:
rfl
/-- `maxTrivSubmodule` is functorial. -/
def maxTrivHom (f : M →ₗ⁅R,L⁆ N) : maxTrivSubmodule R L M →ₗ⁅R,L⁆ maxTrivSubmodule R L N where
  toFun m := ⟨f m, fun x =>
    (LieModuleHom.map_lie _ _ _).symm.trans <|
      (congr_arg f (m.property x)).trans (LieModuleHom.map_zero _)⟩
  map_add' m n := by simp [Function.comp_apply]; rfl -- Porting note:
  map_smul' t m := by 

Proof state:
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : M →ₗ⁅R,L⁆ N
t : R
m : ↥↑(maxTrivSubmodule R L M)
⊢ AddHom.toFun
      { toFun := fun m => { val := f ↑m, property := (_ : ∀ (x : L), ⁅x, f ↑m⁆ = 0) },
        map_add' :=
          (_ :
            ∀ (m n : ↥↑(maxTrivSubmodule R L M)),
              (fun m => { val := f ↑m, property := (_ : ∀ (x : L), ⁅x, f ↑m⁆ = 0) }) (m + n) =
                (fun m => { val := f ↑m, property := (_ : ∀ (x : L), ⁅x, f ↑m⁆ = 0) }) m +
                  (fun m => { val := f ↑m, property := (_ : ∀ (x : L), ⁅x, f ↑m⁆ = 0) }) n) }
      (t • m) =
    (RingHom.id R) t •
      AddHom.toFun
        { toFun := fun m => { val := f ↑m, property := (_ : ∀ (x : L), ⁅x, f ↑m⁆ = 0) },
          map_add' :=
            (_ :
              ∀ (m n : ↥↑(maxTrivSubmodule R L M)),
                (fun m => { val := f ↑m, property := (_ : ∀ (x : L), ⁅x, f ↑m⁆ = 0) }) (m + n) =
                  (fun m => { val := f ↑m, property := (_ : ∀ (x : L), ⁅x, f ↑m⁆ = 0) }) m +
                    (fun m => { val := f ↑m, property := (_ : ∀ (x : L), ⁅x, f ↑m⁆ = 0) }) n) }
        m

Next tactic:
simp [Function.comp_apply]
/-- `maxTrivSubmodule` is functorial. -/
def maxTrivHom (f : M →ₗ⁅R,L⁆ N) : maxTrivSubmodule R L M →ₗ⁅R,L⁆ maxTrivSubmodule R L N where
  toFun m := ⟨f m, fun x =>
    (LieModuleHom.map_lie _ _ _).symm.trans <|
      (congr_arg f (m.property x)).trans (LieModuleHom.map_zero _)⟩
  map_add' m n := by simp [Function.comp_apply]; rfl -- Porting note:
  map_smul' t m := by simp [Function.comp_apply]; 

Proof state:
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : M →ₗ⁅R,L⁆ N
t : R
m : ↥↑(maxTrivSubmodule R L M)
⊢ { val := t • f ↑m, property := (_ : (fun x => x ∈ ↑(maxTrivSubmodule R L N)) (t • f ↑m)) } =
    t • { val := f ↑m, property := (_ : ∀ (x : L), ⁅x, f ↑m⁆ = 0) }

Next tactic:
rfl
/-- The maximal trivial submodules of Lie-equivalent Lie modules are Lie-equivalent. -/
def maxTrivEquiv (e : M ≃ₗ⁅R,L⁆ N) : maxTrivSubmodule R L M ≃ₗ⁅R,L⁆ maxTrivSubmodule R L N :=
  { maxTrivHom (e : M →ₗ⁅R,L⁆ N) with
    toFun := maxTrivHom (e : M →ₗ⁅R,L⁆ N)
    invFun := maxTrivHom (e.symm : N →ₗ⁅R,L⁆ M)
    left_inv := fun m => by 

Proof state:
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
e : M ≃ₗ⁅R,L⁆ N
src✝ : ↥↑(maxTrivSubmodule R L M) →ₗ⁅R,L⁆ ↥↑(maxTrivSubmodule R L N) := maxTrivHom e.toLieModuleHom
m : ↥↑(maxTrivSubmodule R L M)
⊢ (maxTrivHom (LieModuleEquiv.symm e).toLieModuleHom)
      (AddHom.toFun
        (↑{
              toLinearMap :=
                {
                  toAddHom :=
                    { toFun := ⇑(maxTrivHom e.toLieModuleHom),
                      map_add' :=
                        (_ :
                          ∀ (x y : ↥↑(maxTrivSubmodule R L M)),
                            AddHom.toFun src✝.toAddHom (x + y) =
                              AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
                  map_smul' :=
                    (_ :
                      ∀ (r : R) (x : ↥↑(maxTrivSubmodule R L M)),
                        AddHom.toFun src✝.toAddHom (r • x) = (RingHom.id R) r • AddHom.toFun src✝.toAddHom x) },
              map_lie' :=
                (_ :
                  ∀ {x : L} {m : ↥↑(maxTrivSubmodule R L M)},
                    AddHom.toFun src✝.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun src✝.toAddHom m⁆) }).toAddHom
        m) =
    m

Next tactic:
ext
/-- The maximal trivial submodules of Lie-equivalent Lie modules are Lie-equivalent. -/
def maxTrivEquiv (e : M ≃ₗ⁅R,L⁆ N) : maxTrivSubmodule R L M ≃ₗ⁅R,L⁆ maxTrivSubmodule R L N :=
  { maxTrivHom (e : M →ₗ⁅R,L⁆ N) with
    toFun := maxTrivHom (e : M →ₗ⁅R,L⁆ N)
    invFun := maxTrivHom (e.symm : N →ₗ⁅R,L⁆ M)
    left_inv := fun m => by ext; 

Proof state:
case a
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
e : M ≃ₗ⁅R,L⁆ N
src✝ : ↥↑(maxTrivSubmodule R L M) →ₗ⁅R,L⁆ ↥↑(maxTrivSubmodule R L N) := maxTrivHom e.toLieModuleHom
m : ↥↑(maxTrivSubmodule R L M)
⊢ ↑((maxTrivHom (LieModuleEquiv.symm e).toLieModuleHom)
        (AddHom.toFun
          (↑{
                toLinearMap :=
                  {
                    toAddHom :=
                      { toFun := ⇑(maxTrivHom e.toLieModuleHom),
                        map_add' :=
                          (_ :
                            ∀ (x y : ↥↑(maxTrivSubmodule R L M)),
                              AddHom.toFun src✝.toAddHom (x + y) =
                                AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
                    map_smul' :=
                      (_ :
                        ∀ (r : R) (x : ↥↑(maxTrivSubmodule R L M)),
                          AddHom.toFun src✝.toAddHom (r • x) = (RingHom.id R) r • AddHom.toFun src✝.toAddHom x) },
                map_lie' :=
                  (_ :
                    ∀ {x : L} {m : ↥↑(maxTrivSubmodule R L M)},
                      AddHom.toFun src✝.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun src✝.toAddHom m⁆) }).toAddHom
          m)) =
    ↑m

Next tactic:
simp [LieModuleEquiv.coe_to_lieModuleHom]
/-- The maximal trivial submodules of Lie-equivalent Lie modules are Lie-equivalent. -/
def maxTrivEquiv (e : M ≃ₗ⁅R,L⁆ N) : maxTrivSubmodule R L M ≃ₗ⁅R,L⁆ maxTrivSubmodule R L N :=
  { maxTrivHom (e : M →ₗ⁅R,L⁆ N) with
    toFun := maxTrivHom (e : M →ₗ⁅R,L⁆ N)
    invFun := maxTrivHom (e.symm : N →ₗ⁅R,L⁆ M)
    left_inv := fun m => by ext; simp [LieModuleEquiv.coe_to_lieModuleHom]
    right_inv := fun n => by 

Proof state:
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
e : M ≃ₗ⁅R,L⁆ N
src✝ : ↥↑(maxTrivSubmodule R L M) →ₗ⁅R,L⁆ ↥↑(maxTrivSubmodule R L N) := maxTrivHom e.toLieModuleHom
n : ↥↑(maxTrivSubmodule R L N)
⊢ AddHom.toFun
      (↑{
            toLinearMap :=
              {
                toAddHom :=
                  { toFun := ⇑(maxTrivHom e.toLieModuleHom),
                    map_add' :=
                      (_ :
                        ∀ (x y : ↥↑(maxTrivSubmodule R L M)),
                          AddHom.toFun src✝.toAddHom (x + y) =
                            AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
                map_smul' :=
                  (_ :
                    ∀ (r : R) (x : ↥↑(maxTrivSubmodule R L M)),
                      AddHom.toFun src✝.toAddHom (r • x) = (RingHom.id R) r • AddHom.toFun src✝.toAddHom x) },
            map_lie' :=
              (_ :
                ∀ {x : L} {m : ↥↑(maxTrivSubmodule R L M)},
                  AddHom.toFun src✝.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun src✝.toAddHom m⁆) }).toAddHom
      ((maxTrivHom (LieModuleEquiv.symm e).toLieModuleHom) n) =
    n

Next tactic:
ext
/-- The maximal trivial submodules of Lie-equivalent Lie modules are Lie-equivalent. -/
def maxTrivEquiv (e : M ≃ₗ⁅R,L⁆ N) : maxTrivSubmodule R L M ≃ₗ⁅R,L⁆ maxTrivSubmodule R L N :=
  { maxTrivHom (e : M →ₗ⁅R,L⁆ N) with
    toFun := maxTrivHom (e : M →ₗ⁅R,L⁆ N)
    invFun := maxTrivHom (e.symm : N →ₗ⁅R,L⁆ M)
    left_inv := fun m => by ext; simp [LieModuleEquiv.coe_to_lieModuleHom]
    right_inv := fun n => by ext; 

Proof state:
case a
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
e : M ≃ₗ⁅R,L⁆ N
src✝ : ↥↑(maxTrivSubmodule R L M) →ₗ⁅R,L⁆ ↥↑(maxTrivSubmodule R L N) := maxTrivHom e.toLieModuleHom
n : ↥↑(maxTrivSubmodule R L N)
⊢ ↑(AddHom.toFun
        (↑{
              toLinearMap :=
                {
                  toAddHom :=
                    { toFun := ⇑(maxTrivHom e.toLieModuleHom),
                      map_add' :=
                        (_ :
                          ∀ (x y : ↥↑(maxTrivSubmodule R L M)),
                            AddHom.toFun src✝.toAddHom (x + y) =
                              AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
                  map_smul' :=
                    (_ :
                      ∀ (r : R) (x : ↥↑(maxTrivSubmodule R L M)),
                        AddHom.toFun src✝.toAddHom (r • x) = (RingHom.id R) r • AddHom.toFun src✝.toAddHom x) },
              map_lie' :=
                (_ :
                  ∀ {x : L} {m : ↥↑(maxTrivSubmodule R L M)},
                    AddHom.toFun src✝.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun src✝.toAddHom m⁆) }).toAddHom
        ((maxTrivHom (LieModuleEquiv.symm e).toLieModuleHom) n)) =
    ↑n

Next tactic:
simp [LieModuleEquiv.coe_to_lieModuleHom]
@[simp]
theorem maxTrivEquiv_of_refl_eq_refl :
    maxTrivEquiv (LieModuleEquiv.refl : M ≃ₗ⁅R,L⁆ M) = LieModuleEquiv.refl := by
  

Proof state:
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
⊢ maxTrivEquiv LieModuleEquiv.refl = LieModuleEquiv.refl

Next tactic:
ext
@[simp]
theorem maxTrivEquiv_of_refl_eq_refl :
    maxTrivEquiv (LieModuleEquiv.refl : M ≃ₗ⁅R,L⁆ M) = LieModuleEquiv.refl := by
  ext; 

Proof state:
case h.a
R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
m✝ : ↥↑(maxTrivSubmodule R L M)
⊢ ↑((maxTrivEquiv LieModuleEquiv.refl) m✝) = ↑(LieModuleEquiv.refl m✝)

Next tactic:
simp only [coe_maxTrivEquiv_apply, LieModuleEquiv.refl_apply]