[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
t : R
x y z : L
m n : M
⊢ -⁅y, x⁆ = ⁅x, y⁆
[PROOFSTEP]
have h : ⁅x + y, x⁆ + ⁅x + y, y⁆ = 0 := by rw [← lie_add]; apply lie_self
[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
t : R
x y z : L
m n : M
⊢ ⁅x + y, x⁆ + ⁅x + y, y⁆ = 0
[PROOFSTEP]
rw [← lie_add]
[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
t : R
x y z : L
m n : M
⊢ ⁅x + y, x + y⁆ = 0
[PROOFSTEP]
apply lie_self
[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
t : R
x y z : L
m n : M
h : ⁅x + y, x⁆ + ⁅x + y, y⁆ = 0
⊢ -⁅y, x⁆ = ⁅x, y⁆
[PROOFSTEP]
simpa [neg_eq_iff_add_eq_zero] using h
[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
t✝ : R
x✝ y z : L
m✝ n : M
t : R
x m : L
⊢ ⁅t • x, m⁆ = t • ⁅x, m⁆
[PROOFSTEP]
rw [← lie_skew, ← lie_skew x m, LieAlgebra.lie_smul, smul_neg]
[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
t : R
x y z : L
m n : M
⊢ ∀ (t : R) (x m : L), ⁅x, t • m⁆ = t • ⁅x, m⁆
[PROOFSTEP]
apply LieAlgebra.lie_smul
[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
t : R
x y z : L
m n : M
⊢ ⁅-x, m⁆ = -⁅x, m⁆
[PROOFSTEP]
rw [← sub_eq_zero, sub_neg_eq_add, ← add_lie]
[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
t : R
x y z : L
m n : M
⊢ ⁅-x + x, m⁆ = 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
t : R
x y z : L
m n : M
⊢ ⁅x, -m⁆ = -⁅x, m⁆
[PROOFSTEP]
rw [← sub_eq_zero, sub_neg_eq_add, ← lie_add]
[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
t : R
x y z : L
m n : M
⊢ ⁅x, -m + m⁆ = 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
t : R
x y z : L
m n : M
⊢ ⁅x - y, m⁆ = ⁅x, m⁆ - ⁅y, m⁆
[PROOFSTEP]
simp [sub_eq_add_neg]
[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
t : R
x y z : L
m n : M
⊢ ⁅x, m - n⁆ = ⁅x, m⁆ - ⁅x, n⁆
[PROOFSTEP]
simp [sub_eq_add_neg]
[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
t : R
x y z : L
m n : M
⊢ ⁅⁅x, y⁆, m⁆ = ⁅x, ⁅y, m⁆⁆ - ⁅y, ⁅x, m⁆⁆
[PROOFSTEP]
rw [leibniz_lie, add_sub_cancel]
[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
t : R
x y z : L
m n : M
⊢ ⁅x, ⁅y, z⁆⁆ + ⁅y, ⁅z, x⁆⁆ + ⁅z, ⁅x, y⁆⁆ = 0
[PROOFSTEP]
rw [← neg_neg ⁅x, y⁆, lie_neg z, lie_skew y x, ← lie_skew, lie_lie]
[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
t : R
x y z : L
m n : M
⊢ -(⁅y, ⁅z, x⁆⁆ - ⁅z, ⁅y, x⁆⁆) + ⁅y, ⁅z, x⁆⁆ + -⁅z, ⁅y, x⁆⁆ = 0
[PROOFSTEP]
abel
[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
t : R
x y z : L
m n : M
⊢ -(⁅y, ⁅z, x⁆⁆ - ⁅z, ⁅y, x⁆⁆) + ⁅y, ⁅z, x⁆⁆ + -⁅z, ⁅y, x⁆⁆ = 0
[PROOFSTEP]
abel
[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
t : R
x✝ y z : L
m✝ n✝ : M
x : L
f : M →ₗ[R] N
m n : M
⊢ (fun m => ⁅x, ↑f m⁆ - ↑f ⁅x, m⁆) (m + n) = (fun m => ⁅x, ↑f m⁆ - ↑f ⁅x, m⁆) m + (fun m => ⁅x, ↑f m⁆ - ↑f ⁅x, m⁆) n
[PROOFSTEP]
simp only [lie_add, LinearMap.map_add]
[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
t : R
x✝ y z : L
m✝ n✝ : M
x : L
f : M →ₗ[R] N
m n : M
⊢ ⁅x, ↑f m⁆ + ⁅x, ↑f n⁆ - (↑f ⁅x, m⁆ + ↑f ⁅x, n⁆) = ⁅x, ↑f m⁆ - ↑f ⁅x, m⁆ + (⁅x, ↑f n⁆ - ↑f ⁅x, n⁆)
[PROOFSTEP]
abel
[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
t : R
x✝ y z : L
m✝ n✝ : M
x : L
f : M →ₗ[R] N
m n : M
⊢ ⁅x, ↑f m⁆ + ⁅x, ↑f n⁆ - (↑f ⁅x, m⁆ + ↑f ⁅x, n⁆) = ⁅x, ↑f m⁆ - ↑f ⁅x, m⁆ + (⁅x, ↑f n⁆ - ↑f ⁅x, n⁆)
[PROOFSTEP]
abel
[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
t✝ : R
x✝ y z : L
m✝ n : M
x : L
f : M →ₗ[R] N
t : R
m : M
⊢ AddHom.toFun
      { toFun := fun m => ⁅x, ↑f m⁆ - ↑f ⁅x, m⁆,
        map_add' :=
          (_ :
            ∀ (m n : M),
              (fun m => ⁅x, ↑f m⁆ - ↑f ⁅x, m⁆) (m + n) =
                (fun m => ⁅x, ↑f m⁆ - ↑f ⁅x, m⁆) m + (fun m => ⁅x, ↑f m⁆ - ↑f ⁅x, m⁆) n) }
      (t • m) =
    ↑(RingHom.id R) t •
      AddHom.toFun
        { toFun := fun m => ⁅x, ↑f m⁆ - ↑f ⁅x, m⁆,
          map_add' :=
            (_ :
              ∀ (m n : M),
                (fun m => ⁅x, ↑f m⁆ - ↑f ⁅x, m⁆) (m + n) =
                  (fun m => ⁅x, ↑f m⁆ - ↑f ⁅x, m⁆) m + (fun m => ⁅x, ↑f m⁆ - ↑f ⁅x, m⁆) n) }
        m
[PROOFSTEP]
simp only [smul_sub, LinearMap.map_smul, lie_smul, RingHom.id_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
t : R
x✝ y✝ z : L
m n : M
x y : L
f : M →ₗ[R] N
⊢ ⁅x + y, f⁆ = ⁅x, f⁆ + ⁅y, f⁆
[PROOFSTEP]
ext n
[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
t : R
x✝ y✝ z : L
m n✝ : M
x y : L
f : M →ₗ[R] N
n : M
⊢ ↑⁅x + y, f⁆ n = ↑(⁅x, f⁆ + ⁅y, f⁆) n
[PROOFSTEP]
simp only [add_lie, LinearMap.coe_mk, AddHom.coe_mk, LinearMap.add_apply, LinearMap.map_add]
[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
t : R
x✝ y✝ z : L
m n✝ : M
x y : L
f : M →ₗ[R] N
n : M
⊢ ⁅x, ↑f n⁆ + ⁅y, ↑f n⁆ - (↑f ⁅x, n⁆ + ↑f ⁅y, n⁆) = ⁅x, ↑f n⁆ - ↑f ⁅x, n⁆ + (⁅y, ↑f n⁆ - ↑f ⁅y, n⁆)
[PROOFSTEP]
abel
[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
t : R
x✝ y✝ z : L
m n✝ : M
x y : L
f : M →ₗ[R] N
n : M
⊢ ⁅x, ↑f n⁆ + ⁅y, ↑f n⁆ - (↑f ⁅x, n⁆ + ↑f ⁅y, n⁆) = ⁅x, ↑f n⁆ - ↑f ⁅x, n⁆ + (⁅y, ↑f n⁆ - ↑f ⁅y, n⁆)
[PROOFSTEP]
abel
[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
t : R
x✝ y z : L
m n : M
x : L
f g : M →ₗ[R] N
⊢ ⁅x, f + g⁆ = ⁅x, f⁆ + ⁅x, g⁆
[PROOFSTEP]
ext n
[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
t : R
x✝ y z : L
m n✝ : M
x : L
f g : M →ₗ[R] N
n : M
⊢ ↑⁅x, f + g⁆ n = ↑(⁅x, f⁆ + ⁅x, g⁆) n
[PROOFSTEP]
simp only [LinearMap.coe_mk, AddHom.coe_mk, lie_add, LinearMap.add_apply]
[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
t : R
x✝ y z : L
m n✝ : M
x : L
f g : M →ₗ[R] N
n : M
⊢ ⁅x, ↑f n⁆ + ⁅x, ↑g n⁆ - (↑f ⁅x, n⁆ + ↑g ⁅x, n⁆) = ⁅x, ↑f n⁆ - ↑f ⁅x, n⁆ + (⁅x, ↑g n⁆ - ↑g ⁅x, n⁆)
[PROOFSTEP]
abel
[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
t : R
x✝ y z : L
m n✝ : M
x : L
f g : M →ₗ[R] N
n : M
⊢ ⁅x, ↑f n⁆ + ⁅x, ↑g n⁆ - (↑f ⁅x, n⁆ + ↑g ⁅x, n⁆) = ⁅x, ↑f n⁆ - ↑f ⁅x, n⁆ + (⁅x, ↑g n⁆ - ↑g ⁅x, n⁆)
[PROOFSTEP]
abel
[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
t : R
x✝ y✝ z : L
m n : M
x y : L
f : M →ₗ[R] N
⊢ ⁅x, ⁅y, f⁆⁆ = ⁅⁅x, y⁆, f⁆ + ⁅y, ⁅x, f⁆⁆
[PROOFSTEP]
ext n
[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
t : R
x✝ y✝ z : L
m n✝ : M
x y : L
f : M →ₗ[R] N
n : M
⊢ ↑⁅x, ⁅y, f⁆⁆ n = ↑(⁅⁅x, y⁆, f⁆ + ⁅y, ⁅x, f⁆⁆) n
[PROOFSTEP]
simp only [lie_lie, LinearMap.coe_mk, AddHom.coe_mk, LinearMap.map_sub, LinearMap.add_apply, lie_sub]
[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
t : R
x✝ y✝ z : L
m n✝ : M
x y : L
f : M →ₗ[R] N
n : M
⊢ ⁅x, ⁅y, ↑f n⁆⁆ - ⁅x, ↑f ⁅y, n⁆⁆ - (⁅y, ↑f ⁅x, n⁆⁆ - ↑f ⁅y, ⁅x, n⁆⁆) =
    ⁅x, ⁅y, ↑f n⁆⁆ - ⁅y, ⁅x, ↑f n⁆⁆ - (↑f ⁅x, ⁅y, n⁆⁆ - ↑f ⁅y, ⁅x, n⁆⁆) +
      (⁅y, ⁅x, ↑f n⁆⁆ - ⁅y, ↑f ⁅x, n⁆⁆ - (⁅x, ↑f ⁅y, n⁆⁆ - ↑f ⁅x, ⁅y, n⁆⁆))
[PROOFSTEP]
abel
[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
t : R
x✝ y✝ z : L
m n✝ : M
x y : L
f : M →ₗ[R] N
n : M
⊢ ⁅x, ⁅y, ↑f n⁆⁆ - ⁅x, ↑f ⁅y, n⁆⁆ - (⁅y, ↑f ⁅x, n⁆⁆ - ↑f ⁅y, ⁅x, n⁆⁆) =
    ⁅x, ⁅y, ↑f n⁆⁆ - ⁅y, ⁅x, ↑f n⁆⁆ - (↑f ⁅x, ⁅y, n⁆⁆ - ↑f ⁅y, ⁅x, n⁆⁆) +
      (⁅y, ⁅x, ↑f n⁆⁆ - ⁅y, ↑f ⁅x, n⁆⁆ - (⁅x, ↑f ⁅y, n⁆⁆ - ↑f ⁅x, ⁅y, n⁆⁆))
[PROOFSTEP]
abel
[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
t✝ : R
x✝ y z : L
m n : M
t : R
x : L
f : M →ₗ[R] N
⊢ ⁅t • x, f⁆ = t • ⁅x, f⁆
[PROOFSTEP]
ext n
[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
t✝ : R
x✝ y z : L
m n✝ : M
t : R
x : L
f : M →ₗ[R] N
n : M
⊢ ↑⁅t • x, f⁆ n = ↑(t • ⁅x, f⁆) n
[PROOFSTEP]
simp only [smul_sub, smul_lie, LinearMap.smul_apply, LieHom.lie_apply, LinearMap.map_smul]
[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
t✝ : R
x✝ y z : L
m n : M
t : R
x : L
f : M →ₗ[R] N
⊢ ⁅x, t • f⁆ = t • ⁅x, f⁆
[PROOFSTEP]
ext n
[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
t✝ : R
x✝ y z : L
m n✝ : M
t : R
x : L
f : M →ₗ[R] N
n : M
⊢ ↑⁅x, t • f⁆ n = ↑(t • ⁅x, f⁆) n
[PROOFSTEP]
simp only [smul_sub, LinearMap.smul_apply, LieHom.lie_apply, lie_smul]
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
x y : L₁ →ₗ⁅R⁆ L₂
h : (fun f => f.toFun) x = (fun f => f.toFun) y
⊢ x = y
[PROOFSTEP]
cases x
[GOAL]
case mk
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
y : L₁ →ₗ⁅R⁆ L₂
toLinearMap✝ : L₁ →ₗ[R] L₂
map_lie'✝ :
  ∀ {x y : L₁},
    AddHom.toFun toLinearMap✝.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun toLinearMap✝.toAddHom x, AddHom.toFun toLinearMap✝.toAddHom y⁆
h : (fun f => f.toFun) { toLinearMap := toLinearMap✝, map_lie' := map_lie'✝ } = (fun f => f.toFun) y
⊢ { toLinearMap := toLinearMap✝, map_lie' := map_lie'✝ } = y
[PROOFSTEP]
cases y
[GOAL]
case mk.mk
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
toLinearMap✝¹ : L₁ →ₗ[R] L₂
map_lie'✝¹ :
  ∀ {x y : L₁},
    AddHom.toFun toLinearMap✝¹.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun toLinearMap✝¹.toAddHom x, AddHom.toFun toLinearMap✝¹.toAddHom y⁆
toLinearMap✝ : L₁ →ₗ[R] L₂
map_lie'✝ :
  ∀ {x y : L₁},
    AddHom.toFun toLinearMap✝.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun toLinearMap✝.toAddHom x, AddHom.toFun toLinearMap✝.toAddHom y⁆
h :
  (fun f => f.toFun) { toLinearMap := toLinearMap✝¹, map_lie' := map_lie'✝¹ } =
    (fun f => f.toFun) { toLinearMap := toLinearMap✝, map_lie' := map_lie'✝ }
⊢ { toLinearMap := toLinearMap✝¹, map_lie' := map_lie'✝¹ } = { toLinearMap := toLinearMap✝, map_lie' := map_lie'✝ }
[PROOFSTEP]
simp at h 
[GOAL]
case mk.mk
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
toLinearMap✝¹ : L₁ →ₗ[R] L₂
map_lie'✝¹ :
  ∀ {x y : L₁},
    AddHom.toFun toLinearMap✝¹.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun toLinearMap✝¹.toAddHom x, AddHom.toFun toLinearMap✝¹.toAddHom y⁆
toLinearMap✝ : L₁ →ₗ[R] L₂
map_lie'✝ :
  ∀ {x y : L₁},
    AddHom.toFun toLinearMap✝.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun toLinearMap✝.toAddHom x, AddHom.toFun toLinearMap✝.toAddHom y⁆
h : toLinearMap✝¹ = toLinearMap✝
⊢ { toLinearMap := toLinearMap✝¹, map_lie' := map_lie'✝¹ } = { toLinearMap := toLinearMap✝, map_lie' := map_lie'✝ }
[PROOFSTEP]
simp [h]
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
src✝ : L₁ →ₗ[R] L₂ := 0
⊢ ∀ {x y : L₁},
    AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : L₁),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        ⁅x, y⁆ =
      ⁅AddHom.toFun
          { toAddHom := src✝.toAddHom,
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : L₁),
                    AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
          x,
        AddHom.toFun
          { toAddHom := src✝.toAddHom,
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : L₁),
                    AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
          y⁆
[PROOFSTEP]
simp
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
⊢ Injective FunLike.coe
[PROOFSTEP]
rintro ⟨⟨⟨f, _⟩, _⟩, _⟩ ⟨⟨⟨g, _⟩, _⟩, _⟩ h
[GOAL]
case mk.mk.mk.mk.mk.mk
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ → L₂
map_add'✝¹ : ∀ (x y : L₁), f (x + y) = f x + f y
map_smul'✝¹ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } x
map_lie'✝¹ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom y⁆
g : L₁ → L₂
map_add'✝ : ∀ (x y : L₁), g (x + y) = g x + g y
map_smul'✝ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := g, map_add' := map_add'✝ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := g, map_add' := map_add'✝ } x
map_lie'✝ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom y⁆
h :
  ↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
        map_lie' := map_lie'✝¹ } =
    ↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
        map_lie' := map_lie'✝ }
⊢ { toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
      map_lie' := map_lie'✝¹ } =
    { toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
      map_lie' := map_lie'✝ }
[PROOFSTEP]
congr
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f g : L₁ →ₗ⁅R⁆ L₂
⊢ f = g → ∀ (x : L₁), ↑f x = ↑g x
[PROOFSTEP]
rintro rfl x
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
x : L₁
⊢ ↑f x = ↑f x
[PROOFSTEP]
rfl
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
h₁ : ∀ (x y : L₁), ↑f (x + y) = ↑f x + ↑f y
h₂ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := ↑f, map_add' := h₁ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := ↑f, map_add' := h₁ } x
h₃ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := ↑f, map_add' := h₁ }, map_smul' := h₂ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := ↑f, map_add' := h₁ }, map_smul' := h₂ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := ↑f, map_add' := h₁ }, map_smul' := h₂ }.toAddHom y⁆
⊢ { toLinearMap := { toAddHom := { toFun := ↑f, map_add' := h₁ }, map_smul' := h₂ }, map_lie' := h₃ } = f
[PROOFSTEP]
ext
[GOAL]
case h
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
h₁ : ∀ (x y : L₁), ↑f (x + y) = ↑f x + ↑f y
h₂ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := ↑f, map_add' := h₁ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := ↑f, map_add' := h₁ } x
h₃ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := ↑f, map_add' := h₁ }, map_smul' := h₂ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := ↑f, map_add' := h₁ }, map_smul' := h₂ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := ↑f, map_add' := h₁ }, map_smul' := h₂ }.toAddHom y⁆
x✝ : L₁
⊢ ↑{ toLinearMap := { toAddHom := { toFun := ↑f, map_add' := h₁ }, map_smul' := h₂ }, map_lie' := h₃ } x✝ = ↑f x✝
[PROOFSTEP]
rfl
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₂ →ₗ⁅R⁆ L₃
g : L₁ →ₗ⁅R⁆ L₂
src✝ : L₁ →ₗ[R] L₃ := LinearMap.comp ↑f ↑g
⊢ ∀ {x y : L₁},
    AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : L₁),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        ⁅x, y⁆ =
      ⁅AddHom.toFun
          { toAddHom := src✝.toAddHom,
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : L₁),
                    AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
          x,
        AddHom.toFun
          { toAddHom := src✝.toAddHom,
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : L₁),
                    AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
          y⁆
[PROOFSTEP]
intros x y
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₂ →ₗ⁅R⁆ L₃
g : L₁ →ₗ⁅R⁆ L₂
src✝ : L₁ →ₗ[R] L₃ := LinearMap.comp ↑f ↑g
x y : L₁
⊢ AddHom.toFun
      { toAddHom := src✝.toAddHom,
          map_smul' :=
            (_ :
              ∀ (r : R) (x : L₁),
                AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
      ⁅x, y⁆ =
    ⁅AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : L₁),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        x,
      AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : L₁),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        y⁆
[PROOFSTEP]
change f (g ⁅x, y⁆) = ⁅f (g x), f (g y)⁆
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₂ →ₗ⁅R⁆ L₃
g : L₁ →ₗ⁅R⁆ L₂
src✝ : L₁ →ₗ[R] L₃ := LinearMap.comp ↑f ↑g
x y : L₁
⊢ ↑f (↑g ⁅x, y⁆) = ⁅↑f (↑g x), ↑f (↑g y)⁆
[PROOFSTEP]
rw [map_lie, map_lie]
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
⊢ comp f id = f
[PROOFSTEP]
ext
[GOAL]
case h
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
x✝ : L₁
⊢ ↑(comp f id) x✝ = ↑f x✝
[PROOFSTEP]
rfl
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
⊢ comp id f = f
[PROOFSTEP]
ext
[GOAL]
case h
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
x✝ : L₁
⊢ ↑(comp id f) x✝ = ↑f x✝
[PROOFSTEP]
rfl
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
g : L₂ → L₁
h₁ : LeftInverse g ↑f
h₂ : Function.RightInverse g ↑f
src✝ : L₂ →ₗ[R] L₁ := LinearMap.inverse (↑f) g h₁ h₂
⊢ ∀ {x y : L₂},
    AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : L₂),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        ⁅x, y⁆ =
      ⁅AddHom.toFun
          { toAddHom := src✝.toAddHom,
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : L₂),
                    AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
          x,
        AddHom.toFun
          { toAddHom := src✝.toAddHom,
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : L₂),
                    AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
          y⁆
[PROOFSTEP]
intros x y
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
g : L₂ → L₁
h₁ : LeftInverse g ↑f
h₂ : Function.RightInverse g ↑f
src✝ : L₂ →ₗ[R] L₁ := LinearMap.inverse (↑f) g h₁ h₂
x y : L₂
⊢ AddHom.toFun
      { toAddHom := src✝.toAddHom,
          map_smul' :=
            (_ :
              ∀ (r : R) (x : L₂),
                AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
      ⁅x, y⁆ =
    ⁅AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : L₂),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        x,
      AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : L₂),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        y⁆
[PROOFSTEP]
calc
  g ⁅x, y⁆ = g ⁅f (g x), f (g y)⁆ := by conv_lhs => rw [← h₂ x, ← h₂ y]
  _ = g (f ⁅g x, g y⁆) := by rw [map_lie]
  _ = ⁅g x, g y⁆ := h₁ _
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
g : L₂ → L₁
h₁ : LeftInverse g ↑f
h₂ : Function.RightInverse g ↑f
src✝ : L₂ →ₗ[R] L₁ := LinearMap.inverse (↑f) g h₁ h₂
x y : L₂
⊢ g ⁅x, y⁆ = g ⁅↑f (g x), ↑f (g y)⁆
[PROOFSTEP]
conv_lhs => rw [← h₂ x, ← h₂ y]
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
g : L₂ → L₁
h₁ : LeftInverse g ↑f
h₂ : Function.RightInverse g ↑f
src✝ : L₂ →ₗ[R] L₁ := LinearMap.inverse (↑f) g h₁ h₂
x y : L₂
| g ⁅x, y⁆
[PROOFSTEP]
rw [← h₂ x, ← h₂ y]
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
g : L₂ → L₁
h₁ : LeftInverse g ↑f
h₂ : Function.RightInverse g ↑f
src✝ : L₂ →ₗ[R] L₁ := LinearMap.inverse (↑f) g h₁ h₂
x y : L₂
| g ⁅x, y⁆
[PROOFSTEP]
rw [← h₂ x, ← h₂ y]
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
g : L₂ → L₁
h₁ : LeftInverse g ↑f
h₂ : Function.RightInverse g ↑f
src✝ : L₂ →ₗ[R] L₁ := LinearMap.inverse (↑f) g h₁ h₂
x y : L₂
| g ⁅x, y⁆
[PROOFSTEP]
rw [← h₂ x, ← h₂ y]
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
g : L₂ → L₁
h₁ : LeftInverse g ↑f
h₂ : Function.RightInverse g ↑f
src✝ : L₂ →ₗ[R] L₁ := LinearMap.inverse (↑f) g h₁ h₂
x y : L₂
⊢ g ⁅↑f (g x), ↑f (g y)⁆ = g (↑f ⁅g x, g y⁆)
[PROOFSTEP]
rw [map_lie]
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
M : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : AddCommGroup M
inst✝ : LieRingModule L₂ M
f : L₁ →ₗ⁅R⁆ L₂
x y : L₁
m : M
⊢ ⁅x + y, m⁆ = ⁅x, m⁆ + ⁅y, m⁆
[PROOFSTEP]
simp only [LieHom.map_add, add_lie]
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
M : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : AddCommGroup M
inst✝ : LieRingModule L₂ M
f : L₁ →ₗ⁅R⁆ L₂
x y : L₁
m : M
⊢ ⁅x, ⁅y, m⁆⁆ = ⁅⁅x, y⁆, m⁆ + ⁅y, ⁅x, m⁆⁆
[PROOFSTEP]
simp only [lie_lie, sub_add_cancel, LieHom.map_lie]
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
M : Type w₁
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L₁
inst✝⁶ : LieAlgebra R L₁
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M
inst✝² : LieRingModule L₂ M
f : L₁ →ₗ⁅R⁆ L₂
inst✝¹ : Module R M
inst✝ : LieModule R L₂ M
src✝ : LieRingModule L₁ M := LieRingModule.compLieHom M f
t : R
x : L₁
m : M
⊢ ⁅t • x, m⁆ = t • ⁅x, m⁆
[PROOFSTEP]
simp only [LieRingModule.compLieHom_apply, smul_lie, LieHom.map_smul]
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
M : Type w₁
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L₁
inst✝⁶ : LieAlgebra R L₁
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M
inst✝² : LieRingModule L₂ M
f : L₁ →ₗ⁅R⁆ L₂
inst✝¹ : Module R M
inst✝ : LieModule R L₂ M
src✝ : LieRingModule L₁ M := LieRingModule.compLieHom M f
t : R
x : L₁
m : M
⊢ ⁅x, t • m⁆ = t • ⁅x, m⁆
[PROOFSTEP]
simp only [LieRingModule.compLieHom_apply, lie_smul]
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieRing L₂
inst✝³ : LieRing L₃
inst✝² : LieAlgebra R L₁
inst✝¹ : LieAlgebra R L₂
inst✝ : LieAlgebra R L₃
f g : L₁ ≃ₗ⁅R⁆ L₂
h₁ : (fun f => f.toFun) f = (fun f => f.toFun) g
h₂ : (fun f => f.invFun) f = (fun f => f.invFun) g
⊢ f = g
[PROOFSTEP]
cases f
[GOAL]
case mk
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieRing L₂
inst✝³ : LieRing L₃
inst✝² : LieAlgebra R L₁
inst✝¹ : LieAlgebra R L₂
inst✝ : LieAlgebra R L₃
g : L₁ ≃ₗ⁅R⁆ L₂
toLieHom✝ : L₁ →ₗ⁅R⁆ L₂
invFun✝ : L₂ → L₁
left_inv✝ : LeftInverse invFun✝ toLieHom✝.toFun
right_inv✝ : Function.RightInverse invFun✝ toLieHom✝.toFun
h₁ :
  (fun f => f.toFun) { toLieHom := toLieHom✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } =
    (fun f => f.toFun) g
h₂ :
  (fun f => f.invFun) { toLieHom := toLieHom✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } =
    (fun f => f.invFun) g
⊢ { toLieHom := toLieHom✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } = g
[PROOFSTEP]
cases g
[GOAL]
case mk.mk
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieRing L₂
inst✝³ : LieRing L₃
inst✝² : LieAlgebra R L₁
inst✝¹ : LieAlgebra R L₂
inst✝ : LieAlgebra R L₃
toLieHom✝¹ : L₁ →ₗ⁅R⁆ L₂
invFun✝¹ : L₂ → L₁
left_inv✝¹ : LeftInverse invFun✝¹ toLieHom✝¹.toFun
right_inv✝¹ : Function.RightInverse invFun✝¹ toLieHom✝¹.toFun
toLieHom✝ : L₁ →ₗ⁅R⁆ L₂
invFun✝ : L₂ → L₁
left_inv✝ : LeftInverse invFun✝ toLieHom✝.toFun
right_inv✝ : Function.RightInverse invFun✝ toLieHom✝.toFun
h₁ :
  (fun f => f.toFun) { toLieHom := toLieHom✝¹, invFun := invFun✝¹, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
    (fun f => f.toFun) { toLieHom := toLieHom✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }
h₂ :
  (fun f => f.invFun) { toLieHom := toLieHom✝¹, invFun := invFun✝¹, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
    (fun f => f.invFun) { toLieHom := toLieHom✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }
⊢ { toLieHom := toLieHom✝¹, invFun := invFun✝¹, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
    { toLieHom := toLieHom✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }
[PROOFSTEP]
simp at h₁ h₂ 
[GOAL]
case mk.mk
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieRing L₂
inst✝³ : LieRing L₃
inst✝² : LieAlgebra R L₁
inst✝¹ : LieAlgebra R L₂
inst✝ : LieAlgebra R L₃
toLieHom✝¹ : L₁ →ₗ⁅R⁆ L₂
invFun✝¹ : L₂ → L₁
left_inv✝¹ : LeftInverse invFun✝¹ toLieHom✝¹.toFun
right_inv✝¹ : Function.RightInverse invFun✝¹ toLieHom✝¹.toFun
toLieHom✝ : L₁ →ₗ⁅R⁆ L₂
invFun✝ : L₂ → L₁
left_inv✝ : LeftInverse invFun✝ toLieHom✝.toFun
right_inv✝ : Function.RightInverse invFun✝ toLieHom✝.toFun
h₂ : invFun✝¹ = invFun✝
h₁ : toLieHom✝¹ = toLieHom✝
⊢ { toLieHom := toLieHom✝¹, invFun := invFun✝¹, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
    { toLieHom := toLieHom✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }
[PROOFSTEP]
simp [*]
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieRing L₂
inst✝³ : LieRing L₃
inst✝² : LieAlgebra R L₁
inst✝¹ : LieAlgebra R L₂
inst✝ : LieAlgebra R L₃
⊢ Injective toLinearEquiv
[PROOFSTEP]
rintro ⟨⟨⟨⟨f, -⟩, -⟩, -⟩, f_inv⟩ ⟨⟨⟨⟨g, -⟩, -⟩, -⟩, g_inv⟩
[GOAL]
case mk.mk.mk.mk.mk.mk.mk.mk
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieRing L₂
inst✝³ : LieRing L₃
inst✝² : LieAlgebra R L₁
inst✝¹ : LieAlgebra R L₂
inst✝ : LieAlgebra R L₃
f_inv : L₂ → L₁
f : L₁ → L₂
map_add'✝¹ : ∀ (x y : L₁), f (x + y) = f x + f y
map_smul'✝¹ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } x
map_lie'✝¹ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom y⁆
left_inv✝¹ :
  LeftInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
right_inv✝¹ :
  Function.RightInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
g_inv : L₂ → L₁
g : L₁ → L₂
map_add'✝ : ∀ (x y : L₁), g (x + y) = g x + g y
map_smul'✝ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := g, map_add' := map_add'✝ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := g, map_add' := map_add'✝ } x
map_lie'✝ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom y⁆
left_inv✝ :
  LeftInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
right_inv✝ :
  Function.RightInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
⊢ toLinearEquiv
        {
          toLieHom :=
            { toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
              map_lie' := map_lie'✝¹ },
          invFun := f_inv, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
      toLinearEquiv
        {
          toLieHom :=
            { toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
              map_lie' := map_lie'✝ },
          invFun := g_inv, left_inv := left_inv✝, right_inv := right_inv✝ } →
    {
        toLieHom :=
          { toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ },
        invFun := f_inv, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
      {
        toLieHom :=
          { toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ },
        invFun := g_inv, left_inv := left_inv✝, right_inv := right_inv✝ }
[PROOFSTEP]
intro h
[GOAL]
case mk.mk.mk.mk.mk.mk.mk.mk
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieRing L₂
inst✝³ : LieRing L₃
inst✝² : LieAlgebra R L₁
inst✝¹ : LieAlgebra R L₂
inst✝ : LieAlgebra R L₃
f_inv : L₂ → L₁
f : L₁ → L₂
map_add'✝¹ : ∀ (x y : L₁), f (x + y) = f x + f y
map_smul'✝¹ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } x
map_lie'✝¹ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom y⁆
left_inv✝¹ :
  LeftInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
right_inv✝¹ :
  Function.RightInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
g_inv : L₂ → L₁
g : L₁ → L₂
map_add'✝ : ∀ (x y : L₁), g (x + y) = g x + g y
map_smul'✝ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := g, map_add' := map_add'✝ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := g, map_add' := map_add'✝ } x
map_lie'✝ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom y⁆
left_inv✝ :
  LeftInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
right_inv✝ :
  Function.RightInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
h :
  toLinearEquiv
      {
        toLieHom :=
          { toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ },
        invFun := f_inv, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
    toLinearEquiv
      {
        toLieHom :=
          { toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ },
        invFun := g_inv, left_inv := left_inv✝, right_inv := right_inv✝ }
⊢ {
      toLieHom :=
        { toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
          map_lie' := map_lie'✝¹ },
      invFun := f_inv, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
    {
      toLieHom :=
        { toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
          map_lie' := map_lie'✝ },
      invFun := g_inv, left_inv := left_inv✝, right_inv := right_inv✝ }
[PROOFSTEP]
simp only [to_linearEquiv_mk, LinearEquiv.mk.injEq, LinearMap.mk.injEq, AddHom.mk.injEq] at h 
[GOAL]
case mk.mk.mk.mk.mk.mk.mk.mk
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieRing L₂
inst✝³ : LieRing L₃
inst✝² : LieAlgebra R L₁
inst✝¹ : LieAlgebra R L₂
inst✝ : LieAlgebra R L₃
f_inv : L₂ → L₁
f : L₁ → L₂
map_add'✝¹ : ∀ (x y : L₁), f (x + y) = f x + f y
map_smul'✝¹ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } x
map_lie'✝¹ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom y⁆
left_inv✝¹ :
  LeftInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
right_inv✝¹ :
  Function.RightInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
g_inv : L₂ → L₁
g : L₁ → L₂
map_add'✝ : ∀ (x y : L₁), g (x + y) = g x + g y
map_smul'✝ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := g, map_add' := map_add'✝ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := g, map_add' := map_add'✝ } x
map_lie'✝ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom y⁆
left_inv✝ :
  LeftInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
right_inv✝ :
  Function.RightInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
h : f = g ∧ f_inv = g_inv
⊢ {
      toLieHom :=
        { toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
          map_lie' := map_lie'✝¹ },
      invFun := f_inv, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
    {
      toLieHom :=
        { toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
          map_lie' := map_lie'✝ },
      invFun := g_inv, left_inv := left_inv✝, right_inv := right_inv✝ }
[PROOFSTEP]
congr
[GOAL]
case mk.mk.mk.mk.mk.mk.mk.mk.e_toLieHom.e_toLinearMap.e_toAddHom.e_toFun
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieRing L₂
inst✝³ : LieRing L₃
inst✝² : LieAlgebra R L₁
inst✝¹ : LieAlgebra R L₂
inst✝ : LieAlgebra R L₃
f_inv : L₂ → L₁
f : L₁ → L₂
map_add'✝¹ : ∀ (x y : L₁), f (x + y) = f x + f y
map_smul'✝¹ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } x
map_lie'✝¹ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom y⁆
left_inv✝¹ :
  LeftInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
right_inv✝¹ :
  Function.RightInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
g_inv : L₂ → L₁
g : L₁ → L₂
map_add'✝ : ∀ (x y : L₁), g (x + y) = g x + g y
map_smul'✝ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := g, map_add' := map_add'✝ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := g, map_add' := map_add'✝ } x
map_lie'✝ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom y⁆
left_inv✝ :
  LeftInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
right_inv✝ :
  Function.RightInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
h : f = g ∧ f_inv = g_inv
⊢ f = g
case mk.mk.mk.mk.mk.mk.mk.mk.e_invFun
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieRing L₂
inst✝³ : LieRing L₃
inst✝² : LieAlgebra R L₁
inst✝¹ : LieAlgebra R L₂
inst✝ : LieAlgebra R L₃
f_inv : L₂ → L₁
f : L₁ → L₂
map_add'✝¹ : ∀ (x y : L₁), f (x + y) = f x + f y
map_smul'✝¹ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } x
map_lie'✝¹ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom y⁆
left_inv✝¹ :
  LeftInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
right_inv✝¹ :
  Function.RightInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
g_inv : L₂ → L₁
g : L₁ → L₂
map_add'✝ : ∀ (x y : L₁), g (x + y) = g x + g y
map_smul'✝ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := g, map_add' := map_add'✝ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := g, map_add' := map_add'✝ } x
map_lie'✝ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom y⁆
left_inv✝ :
  LeftInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
right_inv✝ :
  Function.RightInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
h : f = g ∧ f_inv = g_inv
⊢ f_inv = g_inv
[PROOFSTEP]
exacts [h.1, h.2]
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieRing L₂
inst✝³ : LieRing L₃
inst✝² : LieAlgebra R L₁
inst✝¹ : LieAlgebra R L₂
inst✝ : LieAlgebra R L₃
e : L₁ ≃ₗ⁅R⁆ L₂
⊢ symm (symm e) = e
[PROOFSTEP]
ext
[GOAL]
case h
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieRing L₂
inst✝³ : LieRing L₃
inst✝² : LieAlgebra R L₁
inst✝¹ : LieAlgebra R L₂
inst✝ : LieAlgebra R L₃
e : L₁ ≃ₗ⁅R⁆ L₂
x✝ : L₁
⊢ ↑(symm (symm e)) x✝ = ↑e x✝
[PROOFSTEP]
rfl
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieRing L₂
inst✝³ : LieRing L₃
inst✝² : LieAlgebra R L₁
inst✝¹ : LieAlgebra R L₂
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
h : Bijective ↑f
src✝ : L₁ ≃ₗ[R] L₂ := LinearEquiv.ofBijective (↑f) h
⊢ ∀ {x y : L₁},
    AddHom.toFun
        {
            toAddHom :=
              { toFun := ↑f,
                map_add' :=
                  (_ :
                    ∀ (x y : L₁),
                      AddHom.toFun src✝.toAddHom (x + y) =
                        AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
            map_smul' :=
              (_ :
                ∀ (r : R) (x : L₁),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        ⁅x, y⁆ =
      ⁅AddHom.toFun
          {
              toAddHom :=
                { toFun := ↑f,
                  map_add' :=
                    (_ :
                      ∀ (x y : L₁),
                        AddHom.toFun src✝.toAddHom (x + y) =
                          AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : L₁),
                    AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
          x,
        AddHom.toFun
          {
              toAddHom :=
                { toFun := ↑f,
                  map_add' :=
                    (_ :
                      ∀ (x y : L₁),
                        AddHom.toFun src✝.toAddHom (x + y) =
                          AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : L₁),
                    AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
          y⁆
[PROOFSTEP]
intros x y
[GOAL]
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieRing L₂
inst✝³ : LieRing L₃
inst✝² : LieAlgebra R L₁
inst✝¹ : LieAlgebra R L₂
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
h : Bijective ↑f
src✝ : L₁ ≃ₗ[R] L₂ := LinearEquiv.ofBijective (↑f) h
x y : L₁
⊢ AddHom.toFun
      {
          toAddHom :=
            { toFun := ↑f,
              map_add' :=
                (_ :
                  ∀ (x y : L₁),
                    AddHom.toFun src✝.toAddHom (x + y) = AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
          map_smul' :=
            (_ :
              ∀ (r : R) (x : L₁),
                AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
      ⁅x, y⁆ =
    ⁅AddHom.toFun
        {
            toAddHom :=
              { toFun := ↑f,
                map_add' :=
                  (_ :
                    ∀ (x y : L₁),
                      AddHom.toFun src✝.toAddHom (x + y) =
                        AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
            map_smul' :=
              (_ :
                ∀ (r : R) (x : L₁),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        x,
      AddHom.toFun
        {
            toAddHom :=
              { toFun := ↑f,
                map_add' :=
                  (_ :
                    ∀ (x y : L₁),
                      AddHom.toFun src✝.toAddHom (x + y) =
                        AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
            map_smul' :=
              (_ :
                ∀ (r : R) (x : L₁),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        y⁆
[PROOFSTEP]
exact f.map_lie x y
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
x y : M →ₗ⁅R,L⁆ N
h : (fun f => f.toFun) x = (fun f => f.toFun) y
⊢ x = y
[PROOFSTEP]
cases x
[GOAL]
case mk
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
y : M →ₗ⁅R,L⁆ N
toLinearMap✝ : M →ₗ[R] N
map_lie'✝ : ∀ {x : L} {m : M}, AddHom.toFun toLinearMap✝.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun toLinearMap✝.toAddHom m⁆
h : (fun f => f.toFun) { toLinearMap := toLinearMap✝, map_lie' := map_lie'✝ } = (fun f => f.toFun) y
⊢ { toLinearMap := toLinearMap✝, map_lie' := map_lie'✝ } = y
[PROOFSTEP]
cases y
[GOAL]
case mk.mk
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
toLinearMap✝¹ : M →ₗ[R] N
map_lie'✝¹ : ∀ {x : L} {m : M}, AddHom.toFun toLinearMap✝¹.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun toLinearMap✝¹.toAddHom m⁆
toLinearMap✝ : M →ₗ[R] N
map_lie'✝ : ∀ {x : L} {m : M}, AddHom.toFun toLinearMap✝.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun toLinearMap✝.toAddHom m⁆
h :
  (fun f => f.toFun) { toLinearMap := toLinearMap✝¹, map_lie' := map_lie'✝¹ } =
    (fun f => f.toFun) { toLinearMap := toLinearMap✝, map_lie' := map_lie'✝ }
⊢ { toLinearMap := toLinearMap✝¹, map_lie' := map_lie'✝¹ } = { toLinearMap := toLinearMap✝, map_lie' := map_lie'✝ }
[PROOFSTEP]
simp at h 
[GOAL]
case mk.mk
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
toLinearMap✝¹ : M →ₗ[R] N
map_lie'✝¹ : ∀ {x : L} {m : M}, AddHom.toFun toLinearMap✝¹.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun toLinearMap✝¹.toAddHom m⁆
toLinearMap✝ : M →ₗ[R] N
map_lie'✝ : ∀ {x : L} {m : M}, AddHom.toFun toLinearMap✝.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun toLinearMap✝.toAddHom m⁆
h : toLinearMap✝¹ = toLinearMap✝
⊢ { toLinearMap := toLinearMap✝¹, map_lie' := map_lie'✝¹ } = { toLinearMap := toLinearMap✝, map_lie' := map_lie'✝ }
[PROOFSTEP]
simp [h]
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : M →ₗ⁅R,L⁆ N →ₗ[R] P
x : L
m : M
n : N
⊢ ⁅x, ↑(↑f m) n⁆ = ↑(↑f ⁅x, m⁆) n + ↑(↑f m) ⁅x, n⁆
[PROOFSTEP]
simp only [sub_add_cancel, map_lie, LieHom.lie_apply]
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
src✝ : M →ₗ[R] N := 0
⊢ ∀ {x : L} {m : M},
    AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : M),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        ⁅x, m⁆ =
      ⁅x,
        AddHom.toFun
          { toAddHom := src✝.toAddHom,
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : M),
                    AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
          m⁆
[PROOFSTEP]
simp
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
⊢ Injective FunLike.coe
[PROOFSTEP]
rintro ⟨⟨⟨f, _⟩⟩⟩ ⟨⟨⟨g, _⟩⟩⟩ h
[GOAL]
case mk.mk.mk.mk.mk.mk
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : M → N
map_add'✝¹ : ∀ (x y : M), f (x + y) = f x + f y
map_smul'✝¹ :
  ∀ (r : R) (x : M),
    AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } x
map_lie'✝¹ :
  ∀ {x : L} {m : M},
    AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom ⁅x, m⁆ =
      ⁅x, AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom m⁆
g : M → N
map_add'✝ : ∀ (x y : M), g (x + y) = g x + g y
map_smul'✝ :
  ∀ (r : R) (x : M),
    AddHom.toFun { toFun := g, map_add' := map_add'✝ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := g, map_add' := map_add'✝ } x
map_lie'✝ :
  ∀ {x : L} {m : M},
    AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom ⁅x, m⁆ =
      ⁅x, AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom m⁆
h :
  ↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
        map_lie' := map_lie'✝¹ } =
    ↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
        map_lie' := map_lie'✝ }
⊢ { toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
      map_lie' := map_lie'✝¹ } =
    { toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
      map_lie' := map_lie'✝ }
[PROOFSTEP]
congr
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f g : M →ₗ⁅R,L⁆ N
⊢ f = g → ∀ (m : M), ↑f m = ↑g m
[PROOFSTEP]
rintro rfl m
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : M →ₗ⁅R,L⁆ N
m : M
⊢ ↑f m = ↑f m
[PROOFSTEP]
rfl
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : M →ₗ⁅R,L⁆ N
h : ∀ {x : L} {m : M}, AddHom.toFun f.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun f.toAddHom m⁆
⊢ { toLinearMap := ↑f, map_lie' := h } = f
[PROOFSTEP]
rfl
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : M →ₗ[R] N
h : ∀ {x : L} {m : M}, AddHom.toFun f.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun f.toAddHom m⁆
⊢ ↑{ toLinearMap := f, map_lie' := h } = ↑f
[PROOFSTEP]
rfl
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : M →ₗ[R] N
h : ∀ {x : L} {m : M}, AddHom.toFun f.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun f.toAddHom m⁆
⊢ ↑{ toLinearMap := f, map_lie' := h } = f
[PROOFSTEP]
rfl
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : N →ₗ⁅R,L⁆ P
g : M →ₗ⁅R,L⁆ N
src✝ : M →ₗ[R] P := LinearMap.comp ↑f ↑g
⊢ ∀ {x : L} {m : M},
    AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : M),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        ⁅x, m⁆ =
      ⁅x,
        AddHom.toFun
          { toAddHom := src✝.toAddHom,
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : M),
                    AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
          m⁆
[PROOFSTEP]
intros x m
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : N →ₗ⁅R,L⁆ P
g : M →ₗ⁅R,L⁆ N
src✝ : M →ₗ[R] P := LinearMap.comp ↑f ↑g
x : L
m : M
⊢ AddHom.toFun
      { toAddHom := src✝.toAddHom,
          map_smul' :=
            (_ :
              ∀ (r : R) (x : M),
                AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
      ⁅x, m⁆ =
    ⁅x,
      AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : M),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        m⁆
[PROOFSTEP]
change f (g ⁅x, m⁆) = ⁅x, f (g m)⁆
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : N →ₗ⁅R,L⁆ P
g : M →ₗ⁅R,L⁆ N
src✝ : M →ₗ[R] P := LinearMap.comp ↑f ↑g
x : L
m : M
⊢ ↑f (↑g ⁅x, m⁆) = ⁅x, ↑f (↑g m)⁆
[PROOFSTEP]
rw [map_lie, map_lie]
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : M →ₗ⁅R,L⁆ N
g : N → M
h₁ : LeftInverse g ↑f
h₂ : Function.RightInverse g ↑f
src✝ : N →ₗ[R] M := LinearMap.inverse (↑f) g h₁ h₂
⊢ ∀ {x : L} {m : N},
    AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : N),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        ⁅x, m⁆ =
      ⁅x,
        AddHom.toFun
          { toAddHom := src✝.toAddHom,
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : N),
                    AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
          m⁆
[PROOFSTEP]
intros x n
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : M →ₗ⁅R,L⁆ N
g : N → M
h₁ : LeftInverse g ↑f
h₂ : Function.RightInverse g ↑f
src✝ : N →ₗ[R] M := LinearMap.inverse (↑f) g h₁ h₂
x : L
n : N
⊢ AddHom.toFun
      { toAddHom := src✝.toAddHom,
          map_smul' :=
            (_ :
              ∀ (r : R) (x : N),
                AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
      ⁅x, n⁆ =
    ⁅x,
      AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : N),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        n⁆
[PROOFSTEP]
calc
  g ⁅x, n⁆ = g ⁅x, f (g n)⁆ := by rw [h₂]
  _ = g (f ⁅x, g n⁆) := by rw [map_lie]
  _ = ⁅x, g n⁆ := h₁ _
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : M →ₗ⁅R,L⁆ N
g : N → M
h₁ : LeftInverse g ↑f
h₂ : Function.RightInverse g ↑f
src✝ : N →ₗ[R] M := LinearMap.inverse (↑f) g h₁ h₂
x : L
n : N
⊢ g ⁅x, n⁆ = g ⁅x, ↑f (g n)⁆
[PROOFSTEP]
rw [h₂]
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : M →ₗ⁅R,L⁆ N
g : N → M
h₁ : LeftInverse g ↑f
h₂ : Function.RightInverse g ↑f
src✝ : N →ₗ[R] M := LinearMap.inverse (↑f) g h₁ h₂
x : L
n : N
⊢ g ⁅x, ↑f (g n)⁆ = g (↑f ⁅x, g n⁆)
[PROOFSTEP]
rw [map_lie]
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f g : M →ₗ⁅R,L⁆ N
src✝ : M →ₗ[R] N := ↑f + ↑g
⊢ ∀ {x : L} {m : M},
    AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : M),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        ⁅x, m⁆ =
      ⁅x,
        AddHom.toFun
          { toAddHom := src✝.toAddHom,
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : M),
                    AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
          m⁆
[PROOFSTEP]
simp
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f g : M →ₗ⁅R,L⁆ N
src✝ : M →ₗ[R] N := ↑f - ↑g
⊢ ∀ {x : L} {m : M},
    AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : M),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        ⁅x, m⁆ =
      ⁅x,
        AddHom.toFun
          { toAddHom := src✝.toAddHom,
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : M),
                    AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
          m⁆
[PROOFSTEP]
simp
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : M →ₗ⁅R,L⁆ N
src✝ : M →ₗ[R] N := -↑f
⊢ ∀ {x : L} {m : M},
    AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : M),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        ⁅x, m⁆ =
      ⁅x,
        AddHom.toFun
          { toAddHom := src✝.toAddHom,
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : M),
                    AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
          m⁆
[PROOFSTEP]
simp
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
n : ℕ
f : M →ₗ⁅R,L⁆ N
src✝ : M →ₗ[R] N := n • ↑f
⊢ ∀ {x : L} {m : M},
    AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : M),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        ⁅x, m⁆ =
      ⁅x,
        AddHom.toFun
          { toAddHom := src✝.toAddHom,
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : M),
                    AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
          m⁆
[PROOFSTEP]
simp
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
z : ℤ
f : M →ₗ⁅R,L⁆ N
src✝ : M →ₗ[R] N := z • ↑f
⊢ ∀ {x : L} {m : M},
    AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : M),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        ⁅x, m⁆ =
      ⁅x,
        AddHom.toFun
          { toAddHom := src✝.toAddHom,
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : M),
                    AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
          m⁆
[PROOFSTEP]
simp
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
t : R
f : M →ₗ⁅R,L⁆ N
src✝ : M →ₗ[R] N := t • ↑f
⊢ ∀ {x : L} {m : M},
    AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : M),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        ⁅x, m⁆ =
      ⁅x,
        AddHom.toFun
          { toAddHom := src✝.toAddHom,
              map_smul' :=
                (_ :
                  ∀ (r : R) (x : M),
                    AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
          m⁆
[PROOFSTEP]
simp
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f g : M ≃ₗ⁅R,L⁆ N
h₁ : (fun f => f.toFun) f = (fun f => f.toFun) g
h₂ : (fun f => f.invFun) f = (fun f => f.invFun) g
⊢ f = g
[PROOFSTEP]
cases f
[GOAL]
case mk
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
g : M ≃ₗ⁅R,L⁆ N
toLieModuleHom✝ : M →ₗ⁅R,L⁆ N
invFun✝ : N → M
left_inv✝ : LeftInverse invFun✝ toLieModuleHom✝.toFun
right_inv✝ : Function.RightInverse invFun✝ toLieModuleHom✝.toFun
h₁ :
  (fun f => f.toFun)
      { toLieModuleHom := toLieModuleHom✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } =
    (fun f => f.toFun) g
h₂ :
  (fun f => f.invFun)
      { toLieModuleHom := toLieModuleHom✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } =
    (fun f => f.invFun) g
⊢ { toLieModuleHom := toLieModuleHom✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } = g
[PROOFSTEP]
cases g
[GOAL]
case mk.mk
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
toLieModuleHom✝¹ : M →ₗ⁅R,L⁆ N
invFun✝¹ : N → M
left_inv✝¹ : LeftInverse invFun✝¹ toLieModuleHom✝¹.toFun
right_inv✝¹ : Function.RightInverse invFun✝¹ toLieModuleHom✝¹.toFun
toLieModuleHom✝ : M →ₗ⁅R,L⁆ N
invFun✝ : N → M
left_inv✝ : LeftInverse invFun✝ toLieModuleHom✝.toFun
right_inv✝ : Function.RightInverse invFun✝ toLieModuleHom✝.toFun
h₁ :
  (fun f => f.toFun)
      { toLieModuleHom := toLieModuleHom✝¹, invFun := invFun✝¹, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
    (fun f => f.toFun)
      { toLieModuleHom := toLieModuleHom✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }
h₂ :
  (fun f => f.invFun)
      { toLieModuleHom := toLieModuleHom✝¹, invFun := invFun✝¹, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
    (fun f => f.invFun)
      { toLieModuleHom := toLieModuleHom✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }
⊢ { toLieModuleHom := toLieModuleHom✝¹, invFun := invFun✝¹, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
    { toLieModuleHom := toLieModuleHom✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }
[PROOFSTEP]
simp at h₁ h₂ 
[GOAL]
case mk.mk
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
toLieModuleHom✝¹ : M →ₗ⁅R,L⁆ N
invFun✝¹ : N → M
left_inv✝¹ : LeftInverse invFun✝¹ toLieModuleHom✝¹.toFun
right_inv✝¹ : Function.RightInverse invFun✝¹ toLieModuleHom✝¹.toFun
toLieModuleHom✝ : M →ₗ⁅R,L⁆ N
invFun✝ : N → M
left_inv✝ : LeftInverse invFun✝ toLieModuleHom✝.toFun
right_inv✝ : Function.RightInverse invFun✝ toLieModuleHom✝.toFun
h₂ : invFun✝¹ = invFun✝
h₁ : toLieModuleHom✝¹ = toLieModuleHom✝
⊢ { toLieModuleHom := toLieModuleHom✝¹, invFun := invFun✝¹, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
    { toLieModuleHom := toLieModuleHom✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }
[PROOFSTEP]
simp [*]
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
⊢ Injective toEquiv
[PROOFSTEP]
rintro ⟨⟨⟨⟨f, -⟩, -⟩, -⟩, f_inv⟩ ⟨⟨⟨⟨g, -⟩, -⟩, -⟩, g_inv⟩
[GOAL]
case mk.mk.mk.mk.mk.mk.mk.mk
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f_inv : N → M
f : M → N
map_add'✝¹ : ∀ (x y : M), f (x + y) = f x + f y
map_smul'✝¹ :
  ∀ (r : R) (x : M),
    AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } x
map_lie'✝¹ :
  ∀ {x : L} {m : M},
    AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom ⁅x, m⁆ =
      ⁅x, AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom m⁆
left_inv✝¹ :
  LeftInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
right_inv✝¹ :
  Function.RightInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
g_inv : N → M
g : M → N
map_add'✝ : ∀ (x y : M), g (x + y) = g x + g y
map_smul'✝ :
  ∀ (r : R) (x : M),
    AddHom.toFun { toFun := g, map_add' := map_add'✝ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := g, map_add' := map_add'✝ } x
map_lie'✝ :
  ∀ {x : L} {m : M},
    AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom ⁅x, m⁆ =
      ⁅x, AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom m⁆
left_inv✝ :
  LeftInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
right_inv✝ :
  Function.RightInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
⊢ toEquiv
        {
          toLieModuleHom :=
            { toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
              map_lie' := map_lie'✝¹ },
          invFun := f_inv, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
      toEquiv
        {
          toLieModuleHom :=
            { toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
              map_lie' := map_lie'✝ },
          invFun := g_inv, left_inv := left_inv✝, right_inv := right_inv✝ } →
    {
        toLieModuleHom :=
          { toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ },
        invFun := f_inv, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
      {
        toLieModuleHom :=
          { toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ },
        invFun := g_inv, left_inv := left_inv✝, right_inv := right_inv✝ }
[PROOFSTEP]
intro h
[GOAL]
case mk.mk.mk.mk.mk.mk.mk.mk
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f_inv : N → M
f : M → N
map_add'✝¹ : ∀ (x y : M), f (x + y) = f x + f y
map_smul'✝¹ :
  ∀ (r : R) (x : M),
    AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } x
map_lie'✝¹ :
  ∀ {x : L} {m : M},
    AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom ⁅x, m⁆ =
      ⁅x, AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom m⁆
left_inv✝¹ :
  LeftInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
right_inv✝¹ :
  Function.RightInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
g_inv : N → M
g : M → N
map_add'✝ : ∀ (x y : M), g (x + y) = g x + g y
map_smul'✝ :
  ∀ (r : R) (x : M),
    AddHom.toFun { toFun := g, map_add' := map_add'✝ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := g, map_add' := map_add'✝ } x
map_lie'✝ :
  ∀ {x : L} {m : M},
    AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom ⁅x, m⁆ =
      ⁅x, AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom m⁆
left_inv✝ :
  LeftInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
right_inv✝ :
  Function.RightInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
h :
  toEquiv
      {
        toLieModuleHom :=
          { toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ },
        invFun := f_inv, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
    toEquiv
      {
        toLieModuleHom :=
          { toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ },
        invFun := g_inv, left_inv := left_inv✝, right_inv := right_inv✝ }
⊢ {
      toLieModuleHom :=
        { toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
          map_lie' := map_lie'✝¹ },
      invFun := f_inv, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
    {
      toLieModuleHom :=
        { toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
          map_lie' := map_lie'✝ },
      invFun := g_inv, left_inv := left_inv✝, right_inv := right_inv✝ }
[PROOFSTEP]
simp only [toEquiv_mk, LieModuleHom.coe_mk, LinearMap.coe_mk, AddHom.coe_mk, Equiv.mk.injEq] at h 
[GOAL]
case mk.mk.mk.mk.mk.mk.mk.mk
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f_inv : N → M
f : M → N
map_add'✝¹ : ∀ (x y : M), f (x + y) = f x + f y
map_smul'✝¹ :
  ∀ (r : R) (x : M),
    AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } x
map_lie'✝¹ :
  ∀ {x : L} {m : M},
    AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom ⁅x, m⁆ =
      ⁅x, AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom m⁆
left_inv✝¹ :
  LeftInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
right_inv✝¹ :
  Function.RightInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
g_inv : N → M
g : M → N
map_add'✝ : ∀ (x y : M), g (x + y) = g x + g y
map_smul'✝ :
  ∀ (r : R) (x : M),
    AddHom.toFun { toFun := g, map_add' := map_add'✝ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := g, map_add' := map_add'✝ } x
map_lie'✝ :
  ∀ {x : L} {m : M},
    AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom ⁅x, m⁆ =
      ⁅x, AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom m⁆
left_inv✝ :
  LeftInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
right_inv✝ :
  Function.RightInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
h : f = g ∧ f_inv = g_inv
⊢ {
      toLieModuleHom :=
        { toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
          map_lie' := map_lie'✝¹ },
      invFun := f_inv, left_inv := left_inv✝¹, right_inv := right_inv✝¹ } =
    {
      toLieModuleHom :=
        { toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
          map_lie' := map_lie'✝ },
      invFun := g_inv, left_inv := left_inv✝, right_inv := right_inv✝ }
[PROOFSTEP]
congr
[GOAL]
case mk.mk.mk.mk.mk.mk.mk.mk.e_toLieModuleHom.e_toLinearMap.e_toAddHom.e_toFun
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f_inv : N → M
f : M → N
map_add'✝¹ : ∀ (x y : M), f (x + y) = f x + f y
map_smul'✝¹ :
  ∀ (r : R) (x : M),
    AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } x
map_lie'✝¹ :
  ∀ {x : L} {m : M},
    AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom ⁅x, m⁆ =
      ⁅x, AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom m⁆
left_inv✝¹ :
  LeftInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
right_inv✝¹ :
  Function.RightInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
g_inv : N → M
g : M → N
map_add'✝ : ∀ (x y : M), g (x + y) = g x + g y
map_smul'✝ :
  ∀ (r : R) (x : M),
    AddHom.toFun { toFun := g, map_add' := map_add'✝ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := g, map_add' := map_add'✝ } x
map_lie'✝ :
  ∀ {x : L} {m : M},
    AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom ⁅x, m⁆ =
      ⁅x, AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom m⁆
left_inv✝ :
  LeftInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
right_inv✝ :
  Function.RightInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
h : f = g ∧ f_inv = g_inv
⊢ f = g
case mk.mk.mk.mk.mk.mk.mk.mk.e_invFun
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f_inv : N → M
f : M → N
map_add'✝¹ : ∀ (x y : M), f (x + y) = f x + f y
map_smul'✝¹ :
  ∀ (r : R) (x : M),
    AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } x
map_lie'✝¹ :
  ∀ {x : L} {m : M},
    AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom ⁅x, m⁆ =
      ⁅x, AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom m⁆
left_inv✝¹ :
  LeftInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
right_inv✝¹ :
  Function.RightInverse f_inv
    (↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
            map_lie' := map_lie'✝¹ }).toAddHom.toFun
g_inv : N → M
g : M → N
map_add'✝ : ∀ (x y : M), g (x + y) = g x + g y
map_smul'✝ :
  ∀ (r : R) (x : M),
    AddHom.toFun { toFun := g, map_add' := map_add'✝ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := g, map_add' := map_add'✝ } x
map_lie'✝ :
  ∀ {x : L} {m : M},
    AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom ⁅x, m⁆ =
      ⁅x, AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom m⁆
left_inv✝ :
  LeftInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
right_inv✝ :
  Function.RightInverse g_inv
    (↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
            map_lie' := map_lie'✝ }).toAddHom.toFun
h : f = g ∧ f_inv = g_inv
⊢ f_inv = g_inv
[PROOFSTEP]
exacts [h.1, h.2]
[GOAL]
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
e : M ≃ₗ⁅R,L⁆ N
⊢ symm (symm e) = e
[PROOFSTEP]
rfl
