[GOAL]
R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
I : LieIdeal R L
h : LieModule.IsTrivial L { x // x ∈ ↑I }
x y : { x // x ∈ ↑I }
⊢ ⁅x, y⁆ = 0
[PROOFSTEP]
apply h.trivial
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L₁
inst✝² : LieRing L₂
inst✝¹ : LieAlgebra R L₁
inst✝ : LieAlgebra R L₂
f : L₁ →ₗ⁅R⁆ L₂
h₁ : Surjective ↑f
h₂ : IsLieAbelian L₁
x y : L₂
⊢ ⁅x, y⁆ = 0
[PROOFSTEP]
obtain ⟨u, rfl⟩ := h₁ x
[GOAL]
case intro
R : Type u
L₁ : Type v
L₂ : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L₁
inst✝² : LieRing L₂
inst✝¹ : LieAlgebra R L₁
inst✝ : LieAlgebra R L₂
f : L₁ →ₗ⁅R⁆ L₂
h₁ : Surjective ↑f
h₂ : IsLieAbelian L₁
y : L₂
u : L₁
⊢ ⁅↑f u, y⁆ = 0
[PROOFSTEP]
obtain ⟨v, rfl⟩ := h₁ y
[GOAL]
case intro.intro
R : Type u
L₁ : Type v
L₂ : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L₁
inst✝² : LieRing L₂
inst✝¹ : LieAlgebra R L₁
inst✝ : LieAlgebra R L₂
f : L₁ →ₗ⁅R⁆ L₂
h₁ : Surjective ↑f
h₂ : IsLieAbelian L₁
u v : L₁
⊢ ⁅↑f u, ↑f v⁆ = 0
[PROOFSTEP]
rw [← LieHom.map_lie, trivial_lie_zero, LieHom.map_zero]
[GOAL]
A : Type v
inst✝ : Ring A
⊢ (IsCommutative A fun x x_1 => x * x_1) ↔ IsLieAbelian A
[PROOFSTEP]
have h₁ : IsCommutative A (· * ·) ↔ ∀ a b : A, a * b = b * a := ⟨fun h => h.1, fun h => ⟨h⟩⟩
[GOAL]
A : Type v
inst✝ : Ring A
h₁ : (IsCommutative A fun x x_1 => x * x_1) ↔ ∀ (a b : A), a * b = b * a
⊢ (IsCommutative A fun x x_1 => x * x_1) ↔ IsLieAbelian A
[PROOFSTEP]
have h₂ : IsLieAbelian A ↔ ∀ a b : A, ⁅a, b⁆ = 0 := ⟨fun h => h.1, fun h => ⟨h⟩⟩
[GOAL]
A : Type v
inst✝ : Ring A
h₁ : (IsCommutative A fun x x_1 => x * x_1) ↔ ∀ (a b : A), a * b = b * a
h₂ : IsLieAbelian A ↔ ∀ (a b : A), ⁅a, b⁆ = 0
⊢ (IsCommutative A fun x x_1 => x * x_1) ↔ IsLieAbelian A
[PROOFSTEP]
simp only [h₁, h₂, LieRing.of_associative_ring_bracket, sub_eq_zero]
[GOAL]
R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x✝¹ x✝ : { x // x ∈ ↑⊥ }
x : L
hx : x ∈ ↑⊥
⊢ ⁅{ val := x, property := hx }, x✝⁆ = 0
[PROOFSTEP]
simp
[GOAL]
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
x : L
⊢ x ∈ LieModule.ker R L M ↔ ∀ (m : M), ⁅x, m⁆ = 0
[PROOFSTEP]
simp only [LieModule.ker, LieHom.mem_ker, LinearMap.ext_iff, LinearMap.zero_apply, toEndomorphism_apply_apply]
[GOAL]
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
x y : M
hx : x ∈ {m | ∀ (x : L), ⁅x, m⁆ = 0}
hy : y ∈ {m | ∀ (x : L), ⁅x, m⁆ = 0}
z : L
⊢ ⁅z, x + y⁆ = 0
[PROOFSTEP]
rw [lie_add, hx, hy, add_zero]
[GOAL]
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
c : R
x : M
hx :
  x ∈
    {
          toAddSubsemigroup :=
            { carrier := {m | ∀ (x : L), ⁅x, m⁆ = 0},
              add_mem' :=
                (_ :
                  ∀ {x y : M},
                    x ∈ {m | ∀ (x : L), ⁅x, m⁆ = 0} → y ∈ {m | ∀ (x : L), ⁅x, m⁆ = 0} → ∀ (z : L), ⁅z, x + y⁆ = 0) },
          zero_mem' := (_ : ∀ (x : L), ⁅x, 0⁆ = 0) }.toAddSubsemigroup.carrier
y : L
⊢ ⁅y, c • x⁆ = 0
[PROOFSTEP]
rw [lie_smul, hx, smul_zero]
[GOAL]
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
x : L
m : M
hm :
  m ∈
    {
            toAddSubmonoid :=
              {
                toAddSubsemigroup :=
                  { carrier := {m | ∀ (x : L), ⁅x, m⁆ = 0},
                    add_mem' :=
                      (_ :
                        ∀ {x y : M},
                          x ∈ {m | ∀ (x : L), ⁅x, m⁆ = 0} →
                            y ∈ {m | ∀ (x : L), ⁅x, m⁆ = 0} → ∀ (z : L), ⁅z, x + y⁆ = 0) },
                zero_mem' := (_ : ∀ (x : L), ⁅x, 0⁆ = 0) },
            smul_mem' :=
              (_ :
                ∀ (c : R) (x : M),
                  x ∈
                      {
                            toAddSubsemigroup :=
                              { carrier := {m | ∀ (x : L), ⁅x, m⁆ = 0},
                                add_mem' :=
                                  (_ :
                                    ∀ {x y : M},
                                      x ∈ {m | ∀ (x : L), ⁅x, m⁆ = 0} →
                                        y ∈ {m | ∀ (x : L), ⁅x, m⁆ = 0} → ∀ (z : L), ⁅z, x + y⁆ = 0) },
                            zero_mem' := (_ : ∀ (x : L), ⁅x, 0⁆ = 0) }.toAddSubsemigroup.carrier →
                    ∀ (y : L), ⁅y, c • x⁆ = 0) }.toAddSubmonoid.toAddSubsemigroup.carrier
y : L
⊢ ⁅y, ⁅x, m⁆⁆ = 0
[PROOFSTEP]
rw [hm, lie_zero]
[GOAL]
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
⊢ ⁅I, maxTrivSubmodule R L M⁆ = ⊥
[PROOFSTEP]
rw [← LieSubmodule.coe_toSubmodule_eq_iff, LieSubmodule.lieIdeal_oper_eq_linear_span, LieSubmodule.bot_coeSubmodule,
  Submodule.span_eq_bot]
[GOAL]
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 : M), x ∈ {m | ∃ x n, ⁅↑x, ↑n⁆ = m} → x = 0
[PROOFSTEP]
rintro m ⟨⟨x, hx⟩, ⟨⟨m, hm⟩, rfl⟩⟩
[GOAL]
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
[PROOFSTEP]
exact hm x
[GOAL]
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⁆ = ⊥
[PROOFSTEP]
refine' ⟨fun h => _, fun h m hm => _⟩
[GOAL]
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⁆ = ⊥
[PROOFSTEP]
rw [← le_bot_iff, ← ideal_oper_maxTrivSubmodule_eq_bot R L M ⊤]
[GOAL]
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⁆
[PROOFSTEP]
exact LieSubmodule.mono_lie_right _ _ ⊤ h
[GOAL]
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
[PROOFSTEP]
rw [mem_maxTrivSubmodule]
[GOAL]
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
[PROOFSTEP]
rw [LieSubmodule.lie_eq_bot_iff] at h
[GOAL]
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 : L), x ∈ ⊤ → ∀ (m : M), m ∈ N → ⁅x, m⁆ = 0
m : M
hm : m ∈ N
⊢ ∀ (x : L), ⁅x, m⁆ = 0
[PROOFSTEP]
exact fun x => h x (LieSubmodule.mem_top x) m hm
[GOAL]
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 = ⊤
[PROOFSTEP]
constructor
[GOAL]
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 = ⊤
[PROOFSTEP]
rintro ⟨h⟩
[GOAL]
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 = ⊤
[PROOFSTEP]
ext
[GOAL]
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✝ ∈ ⊤
[PROOFSTEP]
simp only [mem_maxTrivSubmodule, h, forall_const, LieSubmodule.mem_top]
[GOAL]
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
[PROOFSTEP]
intro h
[GOAL]
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
[PROOFSTEP]
constructor
[GOAL]
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
[PROOFSTEP]
intro x m
[GOAL]
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
[PROOFSTEP]
revert x
[GOAL]
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
[PROOFSTEP]
rw [← mem_maxTrivSubmodule R L M, h]
[GOAL]
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 ∈ ⊤
[PROOFSTEP]
exact LieSubmodule.mem_top m
[GOAL]
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 : { x // x ∈ ↑(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
[PROOFSTEP]
simp [Function.comp_apply]
[GOAL]
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 : { x // x ∈ ↑(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) }
[PROOFSTEP]
rfl
  -- Porting note:
[GOAL]
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 : { x // x ∈ ↑(maxTrivSubmodule R L M) }
⊢ AddHom.toFun
      { toFun := fun m => { val := ↑f ↑m, property := (_ : ∀ (x : L), ⁅x, ↑f ↑m⁆ = 0) },
        map_add' :=
          (_ :
            ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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
[PROOFSTEP]
simp [Function.comp_apply]
[GOAL]
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 : { x // x ∈ ↑(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) }
[PROOFSTEP]
rfl
  -- these two were `by simpa`
[GOAL]
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
x : L
m : { x // x ∈ ↑(maxTrivSubmodule R L M) }
⊢ AddHom.toFun
      {
          toAddHom :=
            { toFun := fun m => { val := ↑f ↑m, property := (_ : ∀ (x : L), ⁅x, ↑f ↑m⁆ = 0) },
              map_add' :=
                (_ :
                  ∀ (m n : { x // x ∈ ↑(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) },
          map_smul' :=
            (_ :
              ∀ (t : R) (m : { x // x ∈ ↑(maxTrivSubmodule R L M) }),
                AddHom.toFun
                    { toFun := fun m => { val := ↑f ↑m, property := (_ : ∀ (x : L), ⁅x, ↑f ↑m⁆ = 0) },
                      map_add' :=
                        (_ :
                          ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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) }.toAddHom
      ⁅x, m⁆ =
    ⁅x,
      AddHom.toFun
        {
            toAddHom :=
              { toFun := fun m => { val := ↑f ↑m, property := (_ : ∀ (x : L), ⁅x, ↑f ↑m⁆ = 0) },
                map_add' :=
                  (_ :
                    ∀ (m n : { x // x ∈ ↑(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) },
            map_smul' :=
              (_ :
                ∀ (t : R) (m : { x // x ∈ ↑(maxTrivSubmodule R L M) }),
                  AddHom.toFun
                      { toFun := fun m => { val := ↑f ↑m, property := (_ : ∀ (x : L), ⁅x, ↑f ↑m⁆ = 0) },
                        map_add' :=
                          (_ :
                            ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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) }.toAddHom
        m⁆
[PROOFSTEP]
simp
[GOAL]
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✝ : { x // x ∈ ↑(maxTrivSubmodule R L M) } →ₗ⁅R,L⁆ { x // x ∈ ↑(maxTrivSubmodule R L N) } :=
  maxTrivHom e.toLieModuleHom
m : { x // x ∈ ↑(maxTrivSubmodule R L M) }
⊢ ↑(maxTrivHom (LieModuleEquiv.symm e).toLieModuleHom)
      (AddHom.toFun
        (↑{
              toLinearMap :=
                {
                  toAddHom :=
                    { toFun := ↑(maxTrivHom e.toLieModuleHom),
                      map_add' :=
                        (_ :
                          ∀ (x y : { x // x ∈ ↑(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 : { x // 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 : { x // x ∈ ↑(maxTrivSubmodule R L M) }},
                    AddHom.toFun src✝.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun src✝.toAddHom m⁆) }).toAddHom
        m) =
    m
[PROOFSTEP]
ext
[GOAL]
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✝ : { x // x ∈ ↑(maxTrivSubmodule R L M) } →ₗ⁅R,L⁆ { x // x ∈ ↑(maxTrivSubmodule R L N) } :=
  maxTrivHom e.toLieModuleHom
m : { x // x ∈ ↑(maxTrivSubmodule R L M) }
⊢ ↑(↑(maxTrivHom (LieModuleEquiv.symm e).toLieModuleHom)
        (AddHom.toFun
          (↑{
                toLinearMap :=
                  {
                    toAddHom :=
                      { toFun := ↑(maxTrivHom e.toLieModuleHom),
                        map_add' :=
                          (_ :
                            ∀ (x y : { x // x ∈ ↑(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 : { x // 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 : { x // x ∈ ↑(maxTrivSubmodule R L M) }},
                      AddHom.toFun src✝.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun src✝.toAddHom m⁆) }).toAddHom
          m)) =
    ↑m
[PROOFSTEP]
simp [LieModuleEquiv.coe_to_lieModuleHom]
[GOAL]
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✝ : { x // x ∈ ↑(maxTrivSubmodule R L M) } →ₗ⁅R,L⁆ { x // x ∈ ↑(maxTrivSubmodule R L N) } :=
  maxTrivHom e.toLieModuleHom
n : { x // x ∈ ↑(maxTrivSubmodule R L N) }
⊢ AddHom.toFun
      (↑{
            toLinearMap :=
              {
                toAddHom :=
                  { toFun := ↑(maxTrivHom e.toLieModuleHom),
                    map_add' :=
                      (_ :
                        ∀ (x y : { x // x ∈ ↑(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 : { x // 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 : { x // x ∈ ↑(maxTrivSubmodule R L M) }},
                  AddHom.toFun src✝.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun src✝.toAddHom m⁆) }).toAddHom
      (↑(maxTrivHom (LieModuleEquiv.symm e).toLieModuleHom) n) =
    n
[PROOFSTEP]
ext
[GOAL]
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✝ : { x // x ∈ ↑(maxTrivSubmodule R L M) } →ₗ⁅R,L⁆ { x // x ∈ ↑(maxTrivSubmodule R L N) } :=
  maxTrivHom e.toLieModuleHom
n : { x // x ∈ ↑(maxTrivSubmodule R L N) }
⊢ ↑(AddHom.toFun
        (↑{
              toLinearMap :=
                {
                  toAddHom :=
                    { toFun := ↑(maxTrivHom e.toLieModuleHom),
                      map_add' :=
                        (_ :
                          ∀ (x y : { x // x ∈ ↑(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 : { x // 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 : { x // x ∈ ↑(maxTrivSubmodule R L M) }},
                    AddHom.toFun src✝.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun src✝.toAddHom m⁆) }).toAddHom
        (↑(maxTrivHom (LieModuleEquiv.symm e).toLieModuleHom) n)) =
    ↑n
[PROOFSTEP]
simp [LieModuleEquiv.coe_to_lieModuleHom]
[GOAL]
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
[PROOFSTEP]
ext
[GOAL]
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✝ : { x // x ∈ ↑(maxTrivSubmodule R L M) }
⊢ ↑(↑(maxTrivEquiv LieModuleEquiv.refl) m✝) = ↑(↑LieModuleEquiv.refl m✝)
[PROOFSTEP]
simp only [coe_maxTrivEquiv_apply, LieModuleEquiv.refl_apply]
[GOAL]
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 : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }
x : L
m : M
⊢ AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆
[PROOFSTEP]
have hf : ⁅x, f.val⁆ m = 0 := by rw [f.property x, LinearMap.zero_apply]
[GOAL]
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 : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }
x : L
m : M
⊢ ↑⁅x, ↑f⁆ m = 0
[PROOFSTEP]
rw [f.property x, LinearMap.zero_apply]
[GOAL]
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 : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }
x : L
m : M
hf : ↑⁅x, ↑f⁆ m = 0
⊢ AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆
[PROOFSTEP]
rw [LieHom.lie_apply, sub_eq_zero, ← LinearMap.toFun_eq_coe] at hf
[GOAL]
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 : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }
x : L
m : M
hf : ⁅x, AddHom.toFun (↑f).toAddHom m⁆ = AddHom.toFun (↑f).toAddHom ⁅x, m⁆
⊢ AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆
[PROOFSTEP]
exact hf.symm
[GOAL]
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 g : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }
⊢ (fun f =>
        { toLinearMap := ↑f,
          map_lie' := (_ : ∀ {x : L} {m : M}, AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
      (f + g) =
    (fun f =>
          { toLinearMap := ↑f,
            map_lie' :=
              (_ : ∀ {x : L} {m : M}, AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
        f +
      (fun f =>
          { toLinearMap := ↑f,
            map_lie' :=
              (_ : ∀ {x : L} {m : M}, AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
        g
[PROOFSTEP]
ext
[GOAL]
case 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
f g : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }
m✝ : M
⊢ ↑((fun f =>
            { toLinearMap := ↑f,
              map_lie' :=
                (_ : ∀ {x : L} {m : M}, AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
          (f + g))
      m✝ =
    ↑((fun f =>
              { toLinearMap := ↑f,
                map_lie' :=
                  (_ : ∀ {x : L} {m : M}, AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
            f +
          (fun f =>
              { toLinearMap := ↑f,
                map_lie' :=
                  (_ : ∀ {x : L} {m : M}, AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
            g)
      m✝
[PROOFSTEP]
simp
[GOAL]
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 : R
G : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }
⊢ AddHom.toFun
      {
        toFun := fun f =>
          { toLinearMap := ↑f,
            map_lie' :=
              (_ : ∀ {x : L} {m : M}, AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) },
        map_add' :=
          (_ :
            ∀ (f g : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }),
              (fun f =>
                    { toLinearMap := ↑f,
                      map_lie' :=
                        (_ :
                          ∀ {x : L} {m : M}, AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                  (f + g) =
                (fun f =>
                      { toLinearMap := ↑f,
                        map_lie' :=
                          (_ :
                            ∀ {x : L} {m : M}, AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                    f +
                  (fun f =>
                      { toLinearMap := ↑f,
                        map_lie' :=
                          (_ :
                            ∀ {x : L} {m : M}, AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                    g) }
      (F • G) =
    ↑(RingHom.id R) F •
      AddHom.toFun
        {
          toFun := fun f =>
            { toLinearMap := ↑f,
              map_lie' :=
                (_ : ∀ {x : L} {m : M}, AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) },
          map_add' :=
            (_ :
              ∀ (f g : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }),
                (fun f =>
                      { toLinearMap := ↑f,
                        map_lie' :=
                          (_ :
                            ∀ {x : L} {m : M}, AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                    (f + g) =
                  (fun f =>
                        { toLinearMap := ↑f,
                          map_lie' :=
                            (_ :
                              ∀ {x : L} {m : M},
                                AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                      f +
                    (fun f =>
                        { toLinearMap := ↑f,
                          map_lie' :=
                            (_ :
                              ∀ {x : L} {m : M},
                                AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                      g) }
        G
[PROOFSTEP]
ext
[GOAL]
case 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
F : R
G : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }
m✝ : M
⊢ ↑(AddHom.toFun
          {
            toFun := fun f =>
              { toLinearMap := ↑f,
                map_lie' :=
                  (_ : ∀ {x : L} {m : M}, AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) },
            map_add' :=
              (_ :
                ∀ (f g : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }),
                  (fun f =>
                        { toLinearMap := ↑f,
                          map_lie' :=
                            (_ :
                              ∀ {x : L} {m : M},
                                AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                      (f + g) =
                    (fun f =>
                          { toLinearMap := ↑f,
                            map_lie' :=
                              (_ :
                                ∀ {x : L} {m : M},
                                  AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                        f +
                      (fun f =>
                          { toLinearMap := ↑f,
                            map_lie' :=
                              (_ :
                                ∀ {x : L} {m : M},
                                  AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                        g) }
          (F • G))
      m✝ =
    ↑(↑(RingHom.id R) F •
          AddHom.toFun
            {
              toFun := fun f =>
                { toLinearMap := ↑f,
                  map_lie' :=
                    (_ : ∀ {x : L} {m : M}, AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) },
              map_add' :=
                (_ :
                  ∀ (f g : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }),
                    (fun f =>
                          { toLinearMap := ↑f,
                            map_lie' :=
                              (_ :
                                ∀ {x : L} {m : M},
                                  AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                        (f + g) =
                      (fun f =>
                            { toLinearMap := ↑f,
                              map_lie' :=
                                (_ :
                                  ∀ {x : L} {m : M},
                                    AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                          f +
                        (fun f =>
                            { toLinearMap := ↑f,
                              map_lie' :=
                                (_ :
                                  ∀ {x : L} {m : M},
                                    AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                          g) }
            G)
      m✝
[PROOFSTEP]
simp
[GOAL]
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
x : L
⊢ ⁅x, ↑F⁆ = 0
[PROOFSTEP]
ext
[GOAL]
case 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
F : M →ₗ⁅R,L⁆ N
x : L
x✝ : M
⊢ ↑⁅x, ↑F⁆ x✝ = ↑0 x✝
[PROOFSTEP]
simp
[GOAL]
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 : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }
⊢ (fun F => { val := ↑F, property := (_ : ∀ (x : L), ⁅x, ↑F⁆ = 0) })
      (AddHom.toFun
        {
            toAddHom :=
              {
                toFun := fun f =>
                  { toLinearMap := ↑f,
                    map_lie' :=
                      (_ : ∀ {x : L} {m : M}, AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) },
                map_add' :=
                  (_ :
                    ∀ (f g : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }),
                      (fun f =>
                            { toLinearMap := ↑f,
                              map_lie' :=
                                (_ :
                                  ∀ {x : L} {m : M},
                                    AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                          (f + g) =
                        (fun f =>
                              { toLinearMap := ↑f,
                                map_lie' :=
                                  (_ :
                                    ∀ {x : L} {m : M},
                                      AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                            f +
                          (fun f =>
                              { toLinearMap := ↑f,
                                map_lie' :=
                                  (_ :
                                    ∀ {x : L} {m : M},
                                      AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                            g) },
            map_smul' :=
              (_ :
                ∀ (F : R) (G : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }),
                  AddHom.toFun
                      {
                        toFun := fun f =>
                          { toLinearMap := ↑f,
                            map_lie' :=
                              (_ :
                                ∀ {x : L} {m : M},
                                  AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) },
                        map_add' :=
                          (_ :
                            ∀ (f g : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }),
                              (fun f =>
                                    { toLinearMap := ↑f,
                                      map_lie' :=
                                        (_ :
                                          ∀ {x : L} {m : M},
                                            AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                  (f + g) =
                                (fun f =>
                                      { toLinearMap := ↑f,
                                        map_lie' :=
                                          (_ :
                                            ∀ {x : L} {m : M},
                                              AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                    f +
                                  (fun f =>
                                      { toLinearMap := ↑f,
                                        map_lie' :=
                                          (_ :
                                            ∀ {x : L} {m : M},
                                              AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                    g) }
                      (F • G) =
                    ↑(RingHom.id R) F •
                      AddHom.toFun
                        {
                          toFun := fun f =>
                            { toLinearMap := ↑f,
                              map_lie' :=
                                (_ :
                                  ∀ {x : L} {m : M},
                                    AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) },
                          map_add' :=
                            (_ :
                              ∀ (f g : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }),
                                (fun f =>
                                      { toLinearMap := ↑f,
                                        map_lie' :=
                                          (_ :
                                            ∀ {x : L} {m : M},
                                              AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                    (f + g) =
                                  (fun f =>
                                        { toLinearMap := ↑f,
                                          map_lie' :=
                                            (_ :
                                              ∀ {x : L} {m : M},
                                                AddHom.toFun (↑f).toAddHom ⁅x, m⁆ =
                                                  ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                      f +
                                    (fun f =>
                                        { toLinearMap := ↑f,
                                          map_lie' :=
                                            (_ :
                                              ∀ {x : L} {m : M},
                                                AddHom.toFun (↑f).toAddHom ⁅x, m⁆ =
                                                  ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                      g) }
                        G) }.toAddHom
        f) =
    f
[PROOFSTEP]
simp
[GOAL]
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
⊢ AddHom.toFun
      {
          toAddHom :=
            {
              toFun := fun f =>
                { toLinearMap := ↑f,
                  map_lie' :=
                    (_ : ∀ {x : L} {m : M}, AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) },
              map_add' :=
                (_ :
                  ∀ (f g : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }),
                    (fun f =>
                          { toLinearMap := ↑f,
                            map_lie' :=
                              (_ :
                                ∀ {x : L} {m : M},
                                  AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                        (f + g) =
                      (fun f =>
                            { toLinearMap := ↑f,
                              map_lie' :=
                                (_ :
                                  ∀ {x : L} {m : M},
                                    AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                          f +
                        (fun f =>
                            { toLinearMap := ↑f,
                              map_lie' :=
                                (_ :
                                  ∀ {x : L} {m : M},
                                    AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                          g) },
          map_smul' :=
            (_ :
              ∀ (F : R) (G : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }),
                AddHom.toFun
                    {
                      toFun := fun f =>
                        { toLinearMap := ↑f,
                          map_lie' :=
                            (_ :
                              ∀ {x : L} {m : M},
                                AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) },
                      map_add' :=
                        (_ :
                          ∀ (f g : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }),
                            (fun f =>
                                  { toLinearMap := ↑f,
                                    map_lie' :=
                                      (_ :
                                        ∀ {x : L} {m : M},
                                          AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                (f + g) =
                              (fun f =>
                                    { toLinearMap := ↑f,
                                      map_lie' :=
                                        (_ :
                                          ∀ {x : L} {m : M},
                                            AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                  f +
                                (fun f =>
                                    { toLinearMap := ↑f,
                                      map_lie' :=
                                        (_ :
                                          ∀ {x : L} {m : M},
                                            AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                  g) }
                    (F • G) =
                  ↑(RingHom.id R) F •
                    AddHom.toFun
                      {
                        toFun := fun f =>
                          { toLinearMap := ↑f,
                            map_lie' :=
                              (_ :
                                ∀ {x : L} {m : M},
                                  AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) },
                        map_add' :=
                          (_ :
                            ∀ (f g : { x // x ∈ ↑(maxTrivSubmodule R L (M →ₗ[R] N)) }),
                              (fun f =>
                                    { toLinearMap := ↑f,
                                      map_lie' :=
                                        (_ :
                                          ∀ {x : L} {m : M},
                                            AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                  (f + g) =
                                (fun f =>
                                      { toLinearMap := ↑f,
                                        map_lie' :=
                                          (_ :
                                            ∀ {x : L} {m : M},
                                              AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                    f +
                                  (fun f =>
                                      { toLinearMap := ↑f,
                                        map_lie' :=
                                          (_ :
                                            ∀ {x : L} {m : M},
                                              AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                    g) }
                      G) }.toAddHom
      ((fun F => { val := ↑F, property := (_ : ∀ (x : L), ⁅x, ↑F⁆ = 0) }) F) =
    F
[PROOFSTEP]
simp
[GOAL]
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 : { x // x ∈ maxTrivSubmodule R L (M →ₗ[R] N) }
⊢ ↑(↑maxTrivLinearMapEquivLieModuleHom f) = ↑↑f
[PROOFSTEP]
ext
[GOAL]
case 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
f : { x // x ∈ maxTrivSubmodule R L (M →ₗ[R] N) }
x✝ : M
⊢ ↑(↑maxTrivLinearMapEquivLieModuleHom f) x✝ = ↑↑f x✝
[PROOFSTEP]
rfl
[GOAL]
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 : { x // x ∈ maxTrivSubmodule R L (M →ₗ[R] N) }
⊢ ↑(↑maxTrivLinearMapEquivLieModuleHom f) = ↑f
[PROOFSTEP]
ext
[GOAL]
case 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
f : { x // x ∈ maxTrivSubmodule R L (M →ₗ[R] N) }
x✝ : M
⊢ ↑↑(↑maxTrivLinearMapEquivLieModuleHom f) x✝ = ↑↑f x✝
[PROOFSTEP]
rfl
[GOAL]
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
⊢ LieModule.ker R L L = center R L
[PROOFSTEP]
ext y
[GOAL]
case 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
y : L
⊢ y ∈ LieModule.ker R L L ↔ y ∈ center R L
[PROOFSTEP]
simp only [LieModule.mem_maxTrivSubmodule, LieModule.mem_ker, ← lie_skew _ y, neg_eq_zero]
[GOAL]
R : Type u
L : Type v
M : 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
N N' : LieSubmodule R L M
I J : LieIdeal R L
inst✝ : LieModule.IsTrivial L M
⊢ ⁅I, N⁆ = ⊥
[PROOFSTEP]
suffices : ⁅I, N⁆ ≤ ⊥
[GOAL]
R : Type u
L : Type v
M : 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
N N' : LieSubmodule R L M
I J : LieIdeal R L
inst✝ : LieModule.IsTrivial L M
this : ⁅I, N⁆ ≤ ⊥
⊢ ⁅I, N⁆ = ⊥
case this
R : Type u
L : Type v
M : 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
N N' : LieSubmodule R L M
I J : LieIdeal R L
inst✝ : LieModule.IsTrivial L M
⊢ ⁅I, N⁆ ≤ ⊥
[PROOFSTEP]
exact le_bot_iff.mp this
[GOAL]
case this
R : Type u
L : Type v
M : 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
N N' : LieSubmodule R L M
I J : LieIdeal R L
inst✝ : LieModule.IsTrivial L M
⊢ ⁅I, N⁆ ≤ ⊥
[PROOFSTEP]
rw [lieIdeal_oper_eq_span, LieSubmodule.lieSpan_le]
[GOAL]
case this
R : Type u
L : Type v
M : 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
N N' : LieSubmodule R L M
I J : LieIdeal R L
inst✝ : LieModule.IsTrivial L M
⊢ {m | ∃ x n, ⁅↑x, ↑n⁆ = m} ⊆ ↑⊥
[PROOFSTEP]
rintro m ⟨x, n, h⟩
[GOAL]
case this.intro.intro
R : Type u
L : Type v
M : 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
N N' : LieSubmodule R L M
I J : LieIdeal R L
inst✝ : LieModule.IsTrivial L M
m : M
x : { x // x ∈ I }
n : { x // x ∈ N }
h : ⁅↑x, ↑n⁆ = m
⊢ m ∈ ↑⊥
[PROOFSTEP]
rw [trivial_lie_zero] at h
[GOAL]
case this.intro.intro
R : Type u
L : Type v
M : 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
N N' : LieSubmodule R L M
I J : LieIdeal R L
inst✝ : LieModule.IsTrivial L M
m : M
x : { x // x ∈ I }
n : { x // x ∈ N }
h : 0 = m
⊢ m ∈ ↑⊥
[PROOFSTEP]
simp [← h]
[GOAL]
R : Type u
L : Type v
M : 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
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ IsLieAbelian { x // x ∈ ↑I } ↔ ⁅I, I⁆ = ⊥
[PROOFSTEP]
simp only [_root_.eq_bot_iff, lieIdeal_oper_eq_span, LieSubmodule.lieSpan_le, LieSubmodule.bot_coe,
  Set.subset_singleton_iff, Set.mem_setOf_eq, exists_imp]
[GOAL]
R : Type u
L : Type v
M : 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
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ IsLieAbelian { x // x ∈ ↑I } ↔ ∀ (y : L) (x : { x // x ∈ I }) (x_1 : { x // x ∈ I }), ⁅↑x, ↑x_1⁆ = y → y = 0
[PROOFSTEP]
refine'
  ⟨fun h z x y hz =>
    hz.symm.trans
      (((I : LieSubalgebra R L).coe_bracket x y).symm.trans ((coe_zero_iff_zero _ _).mpr (by apply h.trivial))),
    fun h => ⟨fun x y => ((I : LieSubalgebra R L).coe_zero_iff_zero _).mp (h _ x y rfl)⟩⟩
[GOAL]
R : Type u
L : Type v
M : 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
N N' : LieSubmodule R L M
I J : LieIdeal R L
h : IsLieAbelian { x // x ∈ ↑I }
z : L
x : { x // x ∈ I }
y : { x // x ∈ I }
hz : ⁅↑x, ↑y⁆ = z
⊢ ⁅x, y⁆ = 0
[PROOFSTEP]
apply h.trivial


[GOAL]
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
f g : AddMonoidAlgebra M ι
⊢ toDirectSum (f * g) = toDirectSum f * toDirectSum g
[PROOFSTEP]
let to_hom : AddMonoidAlgebra M ι →+ ⨁ _ : ι, M :=
  { toFun := toDirectSum
    map_zero' := toDirectSum_zero
    map_add' := toDirectSum_add }
[GOAL]
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
f g : AddMonoidAlgebra M ι
to_hom : AddMonoidAlgebra M ι →+ ⨁ (x : ι), M :=
  { toZeroHom := { toFun := toDirectSum, map_zero' := (_ : toDirectSum 0 = 0) },
    map_add' := (_ : ∀ (f g : AddMonoidAlgebra M ι), toDirectSum (f + g) = toDirectSum f + toDirectSum g) }
⊢ toDirectSum (f * g) = toDirectSum f * toDirectSum g
[PROOFSTEP]
show to_hom (f * g) = to_hom f * to_hom g
[GOAL]
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
f g : AddMonoidAlgebra M ι
to_hom : AddMonoidAlgebra M ι →+ ⨁ (x : ι), M :=
  { toZeroHom := { toFun := toDirectSum, map_zero' := (_ : toDirectSum 0 = 0) },
    map_add' := (_ : ∀ (f g : AddMonoidAlgebra M ι), toDirectSum (f + g) = toDirectSum f + toDirectSum g) }
⊢ ↑to_hom (f * g) = ↑to_hom f * ↑to_hom g
[PROOFSTEP]
let _ : NonUnitalNonAssocSemiring (ι →₀ M) := AddMonoidAlgebra.nonUnitalNonAssocSemiring
[GOAL]
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
f g : AddMonoidAlgebra M ι
to_hom : AddMonoidAlgebra M ι →+ ⨁ (x : ι), M :=
  { toZeroHom := { toFun := toDirectSum, map_zero' := (_ : toDirectSum 0 = 0) },
    map_add' := (_ : ∀ (f g : AddMonoidAlgebra M ι), toDirectSum (f + g) = toDirectSum f + toDirectSum g) }
x✝ : NonUnitalNonAssocSemiring (ι →₀ M) := nonUnitalNonAssocSemiring
⊢ ↑to_hom (f * g) = ↑to_hom f * ↑to_hom g
[PROOFSTEP]
revert f g
[GOAL]
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
to_hom : AddMonoidAlgebra M ι →+ ⨁ (x : ι), M :=
  { toZeroHom := { toFun := toDirectSum, map_zero' := (_ : toDirectSum 0 = 0) },
    map_add' := (_ : ∀ (f g : AddMonoidAlgebra M ι), toDirectSum (f + g) = toDirectSum f + toDirectSum g) }
x✝ : NonUnitalNonAssocSemiring (ι →₀ M) := nonUnitalNonAssocSemiring
⊢ ∀ (f g : AddMonoidAlgebra M ι), ↑to_hom (f * g) = ↑to_hom f * ↑to_hom g
[PROOFSTEP]
rw [AddMonoidHom.map_mul_iff]
  -- porting note: does not find `addHom_ext'`, was `ext (xi xv yi yv) : 4`
[GOAL]
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
to_hom : AddMonoidAlgebra M ι →+ ⨁ (x : ι), M :=
  { toZeroHom := { toFun := toDirectSum, map_zero' := (_ : toDirectSum 0 = 0) },
    map_add' := (_ : ∀ (f g : AddMonoidAlgebra M ι), toDirectSum (f + g) = toDirectSum f + toDirectSum g) }
x✝ : NonUnitalNonAssocSemiring (ι →₀ M) := nonUnitalNonAssocSemiring
⊢ AddMonoidHom.compr₂ AddMonoidHom.mul to_hom = AddMonoidHom.compl₂ (AddMonoidHom.comp AddMonoidHom.mul to_hom) to_hom
[PROOFSTEP]
refine Finsupp.addHom_ext' fun xi => AddMonoidHom.ext fun xv => ?_
[GOAL]
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
to_hom : AddMonoidAlgebra M ι →+ ⨁ (x : ι), M :=
  { toZeroHom := { toFun := toDirectSum, map_zero' := (_ : toDirectSum 0 = 0) },
    map_add' := (_ : ∀ (f g : AddMonoidAlgebra M ι), toDirectSum (f + g) = toDirectSum f + toDirectSum g) }
x✝ : NonUnitalNonAssocSemiring (ι →₀ M) := nonUnitalNonAssocSemiring
xi : ι
xv : M
⊢ ↑(AddMonoidHom.comp (AddMonoidHom.compr₂ AddMonoidHom.mul to_hom) (Finsupp.singleAddHom xi)) xv =
    ↑(AddMonoidHom.comp (AddMonoidHom.compl₂ (AddMonoidHom.comp AddMonoidHom.mul to_hom) to_hom)
          (Finsupp.singleAddHom xi))
      xv
[PROOFSTEP]
refine Finsupp.addHom_ext' fun yi => AddMonoidHom.ext fun yv => ?_
[GOAL]
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
to_hom : AddMonoidAlgebra M ι →+ ⨁ (x : ι), M :=
  { toZeroHom := { toFun := toDirectSum, map_zero' := (_ : toDirectSum 0 = 0) },
    map_add' := (_ : ∀ (f g : AddMonoidAlgebra M ι), toDirectSum (f + g) = toDirectSum f + toDirectSum g) }
x✝ : NonUnitalNonAssocSemiring (ι →₀ M) := nonUnitalNonAssocSemiring
xi : ι
xv : M
yi : ι
yv : M
⊢ ↑(AddMonoidHom.comp (↑(AddMonoidHom.comp (AddMonoidHom.compr₂ AddMonoidHom.mul to_hom) (Finsupp.singleAddHom xi)) xv)
          (Finsupp.singleAddHom yi))
      yv =
    ↑(AddMonoidHom.comp
          (↑(AddMonoidHom.comp (AddMonoidHom.compl₂ (AddMonoidHom.comp AddMonoidHom.mul to_hom) to_hom)
                (Finsupp.singleAddHom xi))
            xv)
          (Finsupp.singleAddHom yi))
      yv
[PROOFSTEP]
dsimp only [AddMonoidHom.comp_apply, AddMonoidHom.compl₂_apply, AddMonoidHom.compr₂_apply, AddMonoidHom.mul_apply,
  Finsupp.singleAddHom_apply]
[GOAL]
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
to_hom : AddMonoidAlgebra M ι →+ ⨁ (x : ι), M :=
  { toZeroHom := { toFun := toDirectSum, map_zero' := (_ : toDirectSum 0 = 0) },
    map_add' := (_ : ∀ (f g : AddMonoidAlgebra M ι), toDirectSum (f + g) = toDirectSum f + toDirectSum g) }
x✝ : NonUnitalNonAssocSemiring (ι →₀ M) := nonUnitalNonAssocSemiring
xi : ι
xv : M
yi : ι
yv : M
⊢ ↑{ toZeroHom := { toFun := toDirectSum, map_zero' := (_ : toDirectSum 0 = 0) },
          map_add' := (_ : ∀ (f g : AddMonoidAlgebra M ι), toDirectSum (f + g) = toDirectSum f + toDirectSum g) }
      (Finsupp.single xi xv * Finsupp.single yi yv) =
    ↑{ toZeroHom := { toFun := toDirectSum, map_zero' := (_ : toDirectSum 0 = 0) },
            map_add' := (_ : ∀ (f g : AddMonoidAlgebra M ι), toDirectSum (f + g) = toDirectSum f + toDirectSum g) }
        (Finsupp.single xi xv) *
      ↑{ toZeroHom := { toFun := toDirectSum, map_zero' := (_ : toDirectSum 0 = 0) },
            map_add' := (_ : ∀ (f g : AddMonoidAlgebra M ι), toDirectSum (f + g) = toDirectSum f + toDirectSum g) }
        (Finsupp.single yi yv)
[PROOFSTEP]
simp only [AddMonoidHom.coe_mk, ZeroHom.coe_mk, toDirectSum_single]
[GOAL]
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
to_hom : AddMonoidAlgebra M ι →+ ⨁ (x : ι), M :=
  { toZeroHom := { toFun := toDirectSum, map_zero' := (_ : toDirectSum 0 = 0) },
    map_add' := (_ : ∀ (f g : AddMonoidAlgebra M ι), toDirectSum (f + g) = toDirectSum f + toDirectSum g) }
x✝ : NonUnitalNonAssocSemiring (ι →₀ M) := nonUnitalNonAssocSemiring
xi : ι
xv : M
yi : ι
yv : M
⊢ toDirectSum (Finsupp.single xi xv * Finsupp.single yi yv) =
    ↑(DirectSum.of (fun i => M) xi) xv * ↑(DirectSum.of (fun i => M) yi) yv
[PROOFSTEP]
erw [AddMonoidAlgebra.single_mul_single, AddMonoidHom.coe_mk, ZeroHom.coe_mk, AddMonoidAlgebra.toDirectSum_single]
[GOAL]
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
to_hom : AddMonoidAlgebra M ι →+ ⨁ (x : ι), M :=
  { toZeroHom := { toFun := toDirectSum, map_zero' := (_ : toDirectSum 0 = 0) },
    map_add' := (_ : ∀ (f g : AddMonoidAlgebra M ι), toDirectSum (f + g) = toDirectSum f + toDirectSum g) }
x✝ : NonUnitalNonAssocSemiring (ι →₀ M) := nonUnitalNonAssocSemiring
xi : ι
xv : M
yi : ι
yv : M
⊢ ↑(DirectSum.of (fun i => M) (xi + yi)) (xv * yv) = DFinsupp.single xi xv * ↑(DirectSum.of (fun i => M) yi) yv
[PROOFSTEP]
simp only [AddMonoidHom.coe_comp, AddMonoidHom.coe_mul, AddMonoidHom.coe_mk, ZeroHom.coe_mk, Function.comp_apply,
  toDirectSum_single, AddMonoidHom.id_apply, Finsupp.singleAddHom_apply, AddMonoidHom.coe_mulLeft]
[GOAL]
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
to_hom : AddMonoidAlgebra M ι →+ ⨁ (x : ι), M :=
  { toZeroHom := { toFun := toDirectSum, map_zero' := (_ : toDirectSum 0 = 0) },
    map_add' := (_ : ∀ (f g : AddMonoidAlgebra M ι), toDirectSum (f + g) = toDirectSum f + toDirectSum g) }
x✝ : NonUnitalNonAssocSemiring (ι →₀ M) := nonUnitalNonAssocSemiring
xi : ι
xv : M
yi : ι
yv : M
⊢ ↑(DirectSum.of (fun i => M) (xi + yi)) (xv * yv) = DFinsupp.single xi xv * ↑(DirectSum.of (fun i => M) yi) yv
[PROOFSTEP]
erw [DirectSum.of_mul_of, Mul.gMul_mul]
[GOAL]
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝³ : DecidableEq ι
inst✝² : AddMonoid ι
inst✝¹ : Semiring M
inst✝ : (m : M) → Decidable (m ≠ 0)
f g : ⨁ (x : ι), M
⊢ toAddMonoidAlgebra (f * g) = toAddMonoidAlgebra f * toAddMonoidAlgebra g
[PROOFSTEP]
apply_fun AddMonoidAlgebra.toDirectSum
[GOAL]
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝³ : DecidableEq ι
inst✝² : AddMonoid ι
inst✝¹ : Semiring M
inst✝ : (m : M) → Decidable (m ≠ 0)
f g : ⨁ (x : ι), M
⊢ AddMonoidAlgebra.toDirectSum (toAddMonoidAlgebra (f * g)) =
    AddMonoidAlgebra.toDirectSum (toAddMonoidAlgebra f * toAddMonoidAlgebra g)
[PROOFSTEP]
simp
[GOAL]
case inj
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝³ : DecidableEq ι
inst✝² : AddMonoid ι
inst✝¹ : Semiring M
inst✝ : (m : M) → Decidable (m ≠ 0)
f g : ⨁ (x : ι), M
⊢ Function.Injective AddMonoidAlgebra.toDirectSum
[PROOFSTEP]
apply Function.LeftInverse.injective
[GOAL]
case inj.a
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝³ : DecidableEq ι
inst✝² : AddMonoid ι
inst✝¹ : Semiring M
inst✝ : (m : M) → Decidable (m ≠ 0)
f g : ⨁ (x : ι), M
⊢ Function.LeftInverse ?inj.g AddMonoidAlgebra.toDirectSum
case inj.g
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝³ : DecidableEq ι
inst✝² : AddMonoid ι
inst✝¹ : Semiring M
inst✝ : (m : M) → Decidable (m ≠ 0)
f g : ⨁ (x : ι), M
⊢ (⨁ (x : ι), M) → AddMonoidAlgebra M ι
[PROOFSTEP]
apply AddMonoidAlgebra.toDirectSum_toAddMonoidAlgebra