[GOAL]
A : Type v
inst✝ : Ring A
x✝² x✝¹ x✝ : A
⊢ ⁅x✝² + x✝¹, x✝⁆ = ⁅x✝², x✝⁆ + ⁅x✝¹, x✝⁆
[PROOFSTEP]
simp only [Ring.lie_def, right_distrib, left_distrib]
[GOAL]
A : Type v
inst✝ : Ring A
x✝² x✝¹ x✝ : A
⊢ x✝² * x✝ + x✝¹ * x✝ - (x✝ * x✝² + x✝ * x✝¹) = x✝² * x✝ - x✝ * x✝² + (x✝¹ * x✝ - x✝ * x✝¹)
[PROOFSTEP]
abel
[GOAL]
A : Type v
inst✝ : Ring A
x✝² x✝¹ x✝ : A
⊢ x✝² * x✝ + x✝¹ * x✝ - (x✝ * x✝² + x✝ * x✝¹) = x✝² * x✝ - x✝ * x✝² + (x✝¹ * x✝ - x✝ * x✝¹)
[PROOFSTEP]
abel
[GOAL]
A : Type v
inst✝ : Ring A
x✝² x✝¹ x✝ : A
⊢ ⁅x✝², x✝¹ + x✝⁆ = ⁅x✝², x✝¹⁆ + ⁅x✝², x✝⁆
[PROOFSTEP]
simp only [Ring.lie_def, right_distrib, left_distrib]
[GOAL]
A : Type v
inst✝ : Ring A
x✝² x✝¹ x✝ : A
⊢ x✝² * x✝¹ + x✝² * x✝ - (x✝¹ * x✝² + x✝ * x✝²) = x✝² * x✝¹ - x✝¹ * x✝² + (x✝² * x✝ - x✝ * x✝²)
[PROOFSTEP]
abel
[GOAL]
A : Type v
inst✝ : Ring A
x✝² x✝¹ x✝ : A
⊢ x✝² * x✝¹ + x✝² * x✝ - (x✝¹ * x✝² + x✝ * x✝²) = x✝² * x✝¹ - x✝¹ * x✝² + (x✝² * x✝ - x✝ * x✝²)
[PROOFSTEP]
abel
[GOAL]
A : Type v
inst✝ : Ring A
⊢ ∀ (x : A), ⁅x, x⁆ = 0
[PROOFSTEP]
simp only [Ring.lie_def, forall_const, sub_self]
[GOAL]
A : Type v
inst✝ : Ring A
x✝² x✝¹ x✝ : A
⊢ ⁅x✝², ⁅x✝¹, x✝⁆⁆ = ⁅⁅x✝², x✝¹⁆, x✝⁆ + ⁅x✝¹, ⁅x✝², x✝⁆⁆
[PROOFSTEP]
simp only [Ring.lie_def, mul_sub_left_distrib, mul_sub_right_distrib, mul_assoc]
[GOAL]
A : Type v
inst✝ : Ring A
x✝² x✝¹ x✝ : A
⊢ x✝² * (x✝¹ * x✝) - x✝² * (x✝ * x✝¹) - (x✝¹ * (x✝ * x✝²) - x✝ * (x✝¹ * x✝²)) =
    x✝² * (x✝¹ * x✝) - x✝¹ * (x✝² * x✝) - (x✝ * (x✝² * x✝¹) - x✝ * (x✝¹ * x✝²)) +
      (x✝¹ * (x✝² * x✝) - x✝¹ * (x✝ * x✝²) - (x✝² * (x✝ * x✝¹) - x✝ * (x✝² * x✝¹)))
[PROOFSTEP]
abel
[GOAL]
A : Type v
inst✝ : Ring A
x✝² x✝¹ x✝ : A
⊢ x✝² * (x✝¹ * x✝) - x✝² * (x✝ * x✝¹) - (x✝¹ * (x✝ * x✝²) - x✝ * (x✝¹ * x✝²)) =
    x✝² * (x✝¹ * x✝) - x✝¹ * (x✝² * x✝) - (x✝ * (x✝² * x✝¹) - x✝ * (x✝¹ * x✝²)) +
      (x✝¹ * (x✝² * x✝) - x✝¹ * (x✝ * x✝²) - (x✝² * (x✝ * x✝¹) - x✝ * (x✝² * x✝¹)))
[PROOFSTEP]
abel
[GOAL]
A : Type v
inst✝² : Ring A
M : Type w
inst✝¹ : AddCommGroup M
inst✝ : Module A M
⊢ ∀ (x y : A) (m : M), ⁅x, ⁅y, m⁆⁆ = ⁅⁅x, y⁆, m⁆ + ⁅y, ⁅x, m⁆⁆
[PROOFSTEP]
simp [LieRing.of_associative_ring_bracket, sub_smul, mul_smul, sub_add_cancel]
[GOAL]
A : Type v
inst✝² : Ring A
R : Type u
inst✝¹ : CommRing R
inst✝ : Algebra R A
t : R
x y : A
⊢ ⁅x, t • y⁆ = t • ⁅x, y⁆
[PROOFSTEP]
rw [LieRing.of_associative_ring_bracket, LieRing.of_associative_ring_bracket, Algebra.mul_smul_comm,
  Algebra.smul_mul_assoc, smul_sub]
[GOAL]
A : Type v
inst✝⁶ : Ring A
R : Type u
inst✝⁵ : CommRing R
inst✝⁴ : Algebra R A
B : Type w
C : Type w₁
inst✝³ : Ring B
inst✝² : Ring C
inst✝¹ : Algebra R B
inst✝ : Algebra R C
f : A →ₐ[R] B
g : B →ₐ[R] C
src✝ : A →ₗ[R] B := toLinearMap f
x✝¹ x✝ : A
⊢ AddHom.toFun
      { toAddHom := src✝.toAddHom,
          map_smul' :=
            (_ :
              ∀ (r : R) (x : A),
                AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
      ⁅x✝¹, x✝⁆ =
    ⁅AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R) (x : A),
                  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 : A),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        x✝⁆
[PROOFSTEP]
simp [LieRing.of_associative_ring_bracket]
[GOAL]
A : Type v
inst✝⁶ : Ring A
R : Type u
inst✝⁵ : CommRing R
inst✝⁴ : Algebra R A
B : Type w
C : Type w₁
inst✝³ : Ring B
inst✝² : Ring C
inst✝¹ : Algebra R B
inst✝ : Algebra R C
f✝ : A →ₐ[R] B
g✝ : B →ₐ[R] C
f g : A →ₐ[R] B
h : toLieHom f = toLieHom g
⊢ f = g
[PROOFSTEP]
ext a
[GOAL]
case H
A : Type v
inst✝⁶ : Ring A
R : Type u
inst✝⁵ : CommRing R
inst✝⁴ : Algebra R A
B : Type w
C : Type w₁
inst✝³ : Ring B
inst✝² : Ring C
inst✝¹ : Algebra R B
inst✝ : Algebra R C
f✝ : A →ₐ[R] B
g✝ : B →ₐ[R] C
f g : A →ₐ[R] B
h : toLieHom f = toLieHom g
a : A
⊢ ↑f a = ↑g a
[PROOFSTEP]
exact LieHom.congr_fun h a
[GOAL]
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : L
⊢ (fun x =>
        { toAddHom := { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
          map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
      (x + y) =
    (fun x =>
          { toAddHom := { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
        x +
      (fun x =>
          { toAddHom := { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
        y
[PROOFSTEP]
ext m
[GOAL]
case h
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : L
m : M
⊢ ↑((fun x =>
            { toAddHom := { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
              map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
          (x + y))
      m =
    ↑((fun x =>
              { toAddHom := { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
            x +
          (fun x =>
              { toAddHom := { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
            y)
      m
[PROOFSTEP]
apply add_lie
[GOAL]
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
t : R
x : L
⊢ AddHom.toFun
      {
        toFun := fun x =>
          { toAddHom := { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
        map_add' :=
          (_ :
            ∀ (x y : L),
              (fun x =>
                    {
                      toAddHom :=
                        { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                      map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                  (x + y) =
                (fun x =>
                      {
                        toAddHom :=
                          { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                        map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                    x +
                  (fun x =>
                      {
                        toAddHom :=
                          { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                        map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                    y) }
      (t • x) =
    ↑(RingHom.id R) t •
      AddHom.toFun
        {
          toFun := fun x =>
            { toAddHom := { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
              map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
          map_add' :=
            (_ :
              ∀ (x y : L),
                (fun x =>
                      {
                        toAddHom :=
                          { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                        map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                    (x + y) =
                  (fun x =>
                        {
                          toAddHom :=
                            { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                          map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                      x +
                    (fun x =>
                        {
                          toAddHom :=
                            { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                          map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                      y) }
        x
[PROOFSTEP]
ext m
[GOAL]
case h
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
t : R
x : L
m : M
⊢ ↑(AddHom.toFun
          {
            toFun := fun x =>
              { toAddHom := { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
            map_add' :=
              (_ :
                ∀ (x y : L),
                  (fun x =>
                        {
                          toAddHom :=
                            { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                          map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                      (x + y) =
                    (fun x =>
                          {
                            toAddHom :=
                              { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                        x +
                      (fun x =>
                          {
                            toAddHom :=
                              { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                        y) }
          (t • x))
      m =
    ↑(↑(RingHom.id R) t •
          AddHom.toFun
            {
              toFun := fun x =>
                { toAddHom := { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                  map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
              map_add' :=
                (_ :
                  ∀ (x y : L),
                    (fun x =>
                          {
                            toAddHom :=
                              { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                        (x + y) =
                      (fun x =>
                            {
                              toAddHom :=
                                { toFun := fun m => ⁅x, m⁆,
                                  map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                              map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                          x +
                        (fun x =>
                            {
                              toAddHom :=
                                { toFun := fun m => ⁅x, m⁆,
                                  map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                              map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                          y) }
            x)
      m
[PROOFSTEP]
apply smul_lie
[GOAL]
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : L
⊢ AddHom.toFun
      {
          toAddHom :=
            {
              toFun := fun x =>
                { toAddHom := { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                  map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
              map_add' :=
                (_ :
                  ∀ (x y : L),
                    (fun x =>
                          {
                            toAddHom :=
                              { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                        (x + y) =
                      (fun x =>
                            {
                              toAddHom :=
                                { toFun := fun m => ⁅x, m⁆,
                                  map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                              map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                          x +
                        (fun x =>
                            {
                              toAddHom :=
                                { toFun := fun m => ⁅x, m⁆,
                                  map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                              map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                          y) },
          map_smul' :=
            (_ :
              ∀ (t : R) (x : L),
                AddHom.toFun
                    {
                      toFun := fun x =>
                        {
                          toAddHom :=
                            { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                          map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
                      map_add' :=
                        (_ :
                          ∀ (x y : L),
                            (fun x =>
                                  {
                                    toAddHom :=
                                      { toFun := fun m => ⁅x, m⁆,
                                        map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                    map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                (x + y) =
                              (fun x =>
                                    {
                                      toAddHom :=
                                        { toFun := fun m => ⁅x, m⁆,
                                          map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                      map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                  x +
                                (fun x =>
                                    {
                                      toAddHom :=
                                        { toFun := fun m => ⁅x, m⁆,
                                          map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                      map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                  y) }
                    (t • x) =
                  ↑(RingHom.id R) t •
                    AddHom.toFun
                      {
                        toFun := fun x =>
                          {
                            toAddHom :=
                              { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
                        map_add' :=
                          (_ :
                            ∀ (x y : L),
                              (fun x =>
                                    {
                                      toAddHom :=
                                        { toFun := fun m => ⁅x, m⁆,
                                          map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                      map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                  (x + y) =
                                (fun x =>
                                      {
                                        toAddHom :=
                                          { toFun := fun m => ⁅x, m⁆,
                                            map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                        map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                    x +
                                  (fun x =>
                                      {
                                        toAddHom :=
                                          { toFun := fun m => ⁅x, m⁆,
                                            map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                        map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                    y) }
                      x) }.toAddHom
      ⁅x, y⁆ =
    ⁅AddHom.toFun
        {
            toAddHom :=
              {
                toFun := fun x =>
                  {
                    toAddHom :=
                      { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                    map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
                map_add' :=
                  (_ :
                    ∀ (x y : L),
                      (fun x =>
                            {
                              toAddHom :=
                                { toFun := fun m => ⁅x, m⁆,
                                  map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                              map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                          (x + y) =
                        (fun x =>
                              {
                                toAddHom :=
                                  { toFun := fun m => ⁅x, m⁆,
                                    map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                            x +
                          (fun x =>
                              {
                                toAddHom :=
                                  { toFun := fun m => ⁅x, m⁆,
                                    map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                            y) },
            map_smul' :=
              (_ :
                ∀ (t : R) (x : L),
                  AddHom.toFun
                      {
                        toFun := fun x =>
                          {
                            toAddHom :=
                              { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
                        map_add' :=
                          (_ :
                            ∀ (x y : L),
                              (fun x =>
                                    {
                                      toAddHom :=
                                        { toFun := fun m => ⁅x, m⁆,
                                          map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                      map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                  (x + y) =
                                (fun x =>
                                      {
                                        toAddHom :=
                                          { toFun := fun m => ⁅x, m⁆,
                                            map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                        map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                    x +
                                  (fun x =>
                                      {
                                        toAddHom :=
                                          { toFun := fun m => ⁅x, m⁆,
                                            map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                        map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                    y) }
                      (t • x) =
                    ↑(RingHom.id R) t •
                      AddHom.toFun
                        {
                          toFun := fun x =>
                            {
                              toAddHom :=
                                { toFun := fun m => ⁅x, m⁆,
                                  map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                              map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
                          map_add' :=
                            (_ :
                              ∀ (x y : L),
                                (fun x =>
                                      {
                                        toAddHom :=
                                          { toFun := fun m => ⁅x, m⁆,
                                            map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                        map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                    (x + y) =
                                  (fun x =>
                                        {
                                          toAddHom :=
                                            { toFun := fun m => ⁅x, m⁆,
                                              map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                          map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                      x +
                                    (fun x =>
                                        {
                                          toAddHom :=
                                            { toFun := fun m => ⁅x, m⁆,
                                              map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                          map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                      y) }
                        x) }.toAddHom
        x,
      AddHom.toFun
        {
            toAddHom :=
              {
                toFun := fun x =>
                  {
                    toAddHom :=
                      { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                    map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
                map_add' :=
                  (_ :
                    ∀ (x y : L),
                      (fun x =>
                            {
                              toAddHom :=
                                { toFun := fun m => ⁅x, m⁆,
                                  map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                              map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                          (x + y) =
                        (fun x =>
                              {
                                toAddHom :=
                                  { toFun := fun m => ⁅x, m⁆,
                                    map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                            x +
                          (fun x =>
                              {
                                toAddHom :=
                                  { toFun := fun m => ⁅x, m⁆,
                                    map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                            y) },
            map_smul' :=
              (_ :
                ∀ (t : R) (x : L),
                  AddHom.toFun
                      {
                        toFun := fun x =>
                          {
                            toAddHom :=
                              { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
                        map_add' :=
                          (_ :
                            ∀ (x y : L),
                              (fun x =>
                                    {
                                      toAddHom :=
                                        { toFun := fun m => ⁅x, m⁆,
                                          map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                      map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                  (x + y) =
                                (fun x =>
                                      {
                                        toAddHom :=
                                          { toFun := fun m => ⁅x, m⁆,
                                            map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                        map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                    x +
                                  (fun x =>
                                      {
                                        toAddHom :=
                                          { toFun := fun m => ⁅x, m⁆,
                                            map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                        map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                    y) }
                      (t • x) =
                    ↑(RingHom.id R) t •
                      AddHom.toFun
                        {
                          toFun := fun x =>
                            {
                              toAddHom :=
                                { toFun := fun m => ⁅x, m⁆,
                                  map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                              map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
                          map_add' :=
                            (_ :
                              ∀ (x y : L),
                                (fun x =>
                                      {
                                        toAddHom :=
                                          { toFun := fun m => ⁅x, m⁆,
                                            map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                        map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                    (x + y) =
                                  (fun x =>
                                        {
                                          toAddHom :=
                                            { toFun := fun m => ⁅x, m⁆,
                                              map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                          map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                      x +
                                    (fun x =>
                                        {
                                          toAddHom :=
                                            { toFun := fun m => ⁅x, m⁆,
                                              map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                          map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                      y) }
                        x) }.toAddHom
        y⁆
[PROOFSTEP]
ext m
[GOAL]
case h
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : L
m : M
⊢ ↑(AddHom.toFun
          {
              toAddHom :=
                {
                  toFun := fun x =>
                    {
                      toAddHom :=
                        { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                      map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
                  map_add' :=
                    (_ :
                      ∀ (x y : L),
                        (fun x =>
                              {
                                toAddHom :=
                                  { toFun := fun m => ⁅x, m⁆,
                                    map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                            (x + y) =
                          (fun x =>
                                {
                                  toAddHom :=
                                    { toFun := fun m => ⁅x, m⁆,
                                      map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                  map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                              x +
                            (fun x =>
                                {
                                  toAddHom :=
                                    { toFun := fun m => ⁅x, m⁆,
                                      map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                  map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                              y) },
              map_smul' :=
                (_ :
                  ∀ (t : R) (x : L),
                    AddHom.toFun
                        {
                          toFun := fun x =>
                            {
                              toAddHom :=
                                { toFun := fun m => ⁅x, m⁆,
                                  map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                              map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
                          map_add' :=
                            (_ :
                              ∀ (x y : L),
                                (fun x =>
                                      {
                                        toAddHom :=
                                          { toFun := fun m => ⁅x, m⁆,
                                            map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                        map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                    (x + y) =
                                  (fun x =>
                                        {
                                          toAddHom :=
                                            { toFun := fun m => ⁅x, m⁆,
                                              map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                          map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                      x +
                                    (fun x =>
                                        {
                                          toAddHom :=
                                            { toFun := fun m => ⁅x, m⁆,
                                              map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                          map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                      y) }
                        (t • x) =
                      ↑(RingHom.id R) t •
                        AddHom.toFun
                          {
                            toFun := fun x =>
                              {
                                toAddHom :=
                                  { toFun := fun m => ⁅x, m⁆,
                                    map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
                            map_add' :=
                              (_ :
                                ∀ (x y : L),
                                  (fun x =>
                                        {
                                          toAddHom :=
                                            { toFun := fun m => ⁅x, m⁆,
                                              map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                          map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                      (x + y) =
                                    (fun x =>
                                          {
                                            toAddHom :=
                                              { toFun := fun m => ⁅x, m⁆,
                                                map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                        x +
                                      (fun x =>
                                          {
                                            toAddHom :=
                                              { toFun := fun m => ⁅x, m⁆,
                                                map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                        y) }
                          x) }.toAddHom
          ⁅x, y⁆)
      m =
    ↑⁅AddHom.toFun
            {
                toAddHom :=
                  {
                    toFun := fun x =>
                      {
                        toAddHom :=
                          { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                        map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
                    map_add' :=
                      (_ :
                        ∀ (x y : L),
                          (fun x =>
                                {
                                  toAddHom :=
                                    { toFun := fun m => ⁅x, m⁆,
                                      map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                  map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                              (x + y) =
                            (fun x =>
                                  {
                                    toAddHom :=
                                      { toFun := fun m => ⁅x, m⁆,
                                        map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                    map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                x +
                              (fun x =>
                                  {
                                    toAddHom :=
                                      { toFun := fun m => ⁅x, m⁆,
                                        map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                    map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                y) },
                map_smul' :=
                  (_ :
                    ∀ (t : R) (x : L),
                      AddHom.toFun
                          {
                            toFun := fun x =>
                              {
                                toAddHom :=
                                  { toFun := fun m => ⁅x, m⁆,
                                    map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
                            map_add' :=
                              (_ :
                                ∀ (x y : L),
                                  (fun x =>
                                        {
                                          toAddHom :=
                                            { toFun := fun m => ⁅x, m⁆,
                                              map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                          map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                      (x + y) =
                                    (fun x =>
                                          {
                                            toAddHom :=
                                              { toFun := fun m => ⁅x, m⁆,
                                                map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                        x +
                                      (fun x =>
                                          {
                                            toAddHom :=
                                              { toFun := fun m => ⁅x, m⁆,
                                                map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                        y) }
                          (t • x) =
                        ↑(RingHom.id R) t •
                          AddHom.toFun
                            {
                              toFun := fun x =>
                                {
                                  toAddHom :=
                                    { toFun := fun m => ⁅x, m⁆,
                                      map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                  map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
                              map_add' :=
                                (_ :
                                  ∀ (x y : L),
                                    (fun x =>
                                          {
                                            toAddHom :=
                                              { toFun := fun m => ⁅x, m⁆,
                                                map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                        (x + y) =
                                      (fun x =>
                                            {
                                              toAddHom :=
                                                { toFun := fun m => ⁅x, m⁆,
                                                  map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                              map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                          x +
                                        (fun x =>
                                            {
                                              toAddHom :=
                                                { toFun := fun m => ⁅x, m⁆,
                                                  map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                              map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                          y) }
                            x) }.toAddHom
            x,
          AddHom.toFun
            {
                toAddHom :=
                  {
                    toFun := fun x =>
                      {
                        toAddHom :=
                          { toFun := fun m => ⁅x, m⁆, map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                        map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
                    map_add' :=
                      (_ :
                        ∀ (x y : L),
                          (fun x =>
                                {
                                  toAddHom :=
                                    { toFun := fun m => ⁅x, m⁆,
                                      map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                  map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                              (x + y) =
                            (fun x =>
                                  {
                                    toAddHom :=
                                      { toFun := fun m => ⁅x, m⁆,
                                        map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                    map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                x +
                              (fun x =>
                                  {
                                    toAddHom :=
                                      { toFun := fun m => ⁅x, m⁆,
                                        map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                    map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                y) },
                map_smul' :=
                  (_ :
                    ∀ (t : R) (x : L),
                      AddHom.toFun
                          {
                            toFun := fun x =>
                              {
                                toAddHom :=
                                  { toFun := fun m => ⁅x, m⁆,
                                    map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
                            map_add' :=
                              (_ :
                                ∀ (x y : L),
                                  (fun x =>
                                        {
                                          toAddHom :=
                                            { toFun := fun m => ⁅x, m⁆,
                                              map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                          map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                      (x + y) =
                                    (fun x =>
                                          {
                                            toAddHom :=
                                              { toFun := fun m => ⁅x, m⁆,
                                                map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                        x +
                                      (fun x =>
                                          {
                                            toAddHom :=
                                              { toFun := fun m => ⁅x, m⁆,
                                                map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                        y) }
                          (t • x) =
                        ↑(RingHom.id R) t •
                          AddHom.toFun
                            {
                              toFun := fun x =>
                                {
                                  toAddHom :=
                                    { toFun := fun m => ⁅x, m⁆,
                                      map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                  map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) },
                              map_add' :=
                                (_ :
                                  ∀ (x y : L),
                                    (fun x =>
                                          {
                                            toAddHom :=
                                              { toFun := fun m => ⁅x, m⁆,
                                                map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                            map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                        (x + y) =
                                      (fun x =>
                                            {
                                              toAddHom :=
                                                { toFun := fun m => ⁅x, m⁆,
                                                  map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                              map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                          x +
                                        (fun x =>
                                            {
                                              toAddHom :=
                                                { toFun := fun m => ⁅x, m⁆,
                                                  map_add' := (_ : ∀ (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆) },
                                              map_smul' := (_ : ∀ (t : R) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆) })
                                          y) }
                            x) }.toAddHom
            y⁆
      m
[PROOFSTEP]
apply lie_lie
[GOAL]
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
⊢ toEndomorphism R (Module.End R M) M = LieHom.id
[PROOFSTEP]
ext g m
[GOAL]
case h.h
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
g : Module.End R M
m : M
⊢ ↑(↑(toEndomorphism R (Module.End R M) M) g) m = ↑(↑LieHom.id g) m
[PROOFSTEP]
simp [lie_eq_smul]
[GOAL]
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x : L
⊢ Submodule.map (↑(toEndomorphism R L M) x) ↑N ≤ ↑N
[PROOFSTEP]
rintro n ⟨m, hm, rfl⟩
[GOAL]
case intro.intro
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x : L
m : M
hm : m ∈ ↑↑N
⊢ ↑(↑(toEndomorphism R L M) x) m ∈ ↑N
[PROOFSTEP]
exact N.lie_mem hm
[GOAL]
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x : L
m : M
hm : m ∈ ↑N
⊢ ↑(LinearMap.comp (↑(toEndomorphism R L M) x) (Submodule.subtype ↑N)) { val := m, property := hm } ∈ ↑N
[PROOFSTEP]
simpa using N.lie_mem hm
[GOAL]
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x : L
h :
  optParam
    (∀ (m : M) (hm : m ∈ ↑N),
      ↑(LinearMap.comp (↑(toEndomorphism R L M) x) (Submodule.subtype ↑N)) { val := m, property := hm } ∈ ↑N)
    (_ :
      ∀ (m : M) (hm : m ∈ ↑N),
        ↑(LinearMap.comp (↑(toEndomorphism R L M) x) (Submodule.subtype ↑N)) { val := m, property := hm } ∈ ↑N)
⊢ LinearMap.restrict (↑(toEndomorphism R L M) x) h = ↑(toEndomorphism R L { x // x ∈ ↑N }) x
[PROOFSTEP]
ext
[GOAL]
case h.a
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x : L
h :
  optParam
    (∀ (m : M) (hm : m ∈ ↑N),
      ↑(LinearMap.comp (↑(toEndomorphism R L M) x) (Submodule.subtype ↑N)) { val := m, property := hm } ∈ ↑N)
    (_ :
      ∀ (m : M) (hm : m ∈ ↑N),
        ↑(LinearMap.comp (↑(toEndomorphism R L M) x) (Submodule.subtype ↑N)) { val := m, property := hm } ∈ ↑N)
x✝ : { x // x ∈ ↑N }
⊢ ↑(↑(LinearMap.restrict (↑(toEndomorphism R L M) x) h) x✝) = ↑(↑(↑(toEndomorphism R L { x // x ∈ ↑N }) x) x✝)
[PROOFSTEP]
simp [LinearMap.restrict_apply]
[GOAL]
R : Type u
L : Type v
M : Type w
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
A : Type v
inst✝¹ : Ring A
inst✝ : Algebra R A
⊢ ↑(ad R A) = LinearMap.mulLeft R - LinearMap.mulRight R
[PROOFSTEP]
ext a b
[GOAL]
case h.h
R : Type u
L : Type v
M : Type w
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
A : Type v
inst✝¹ : Ring A
inst✝ : Algebra R A
a b : A
⊢ ↑(↑(ad R A) a) b = ↑((LinearMap.mulLeft R - LinearMap.mulRight R) a) b
[PROOFSTEP]
simp [LieRing.of_associative_ring_bracket]
[GOAL]
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K : LieSubalgebra R L
x : { x // x ∈ K }
⊢ LinearMap.comp (↑(ad R L) ↑x) ↑(incl K) = LinearMap.comp (↑(incl K)) (↑(ad R { x // x ∈ K }) x)
[PROOFSTEP]
ext y
[GOAL]
case h
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K : LieSubalgebra R L
x y : { x // x ∈ K }
⊢ ↑(LinearMap.comp (↑(ad R L) ↑x) ↑(incl K)) y = ↑(LinearMap.comp (↑(incl K)) (↑(ad R { x // x ∈ K }) x)) y
[PROOFSTEP]
simp only [ad_apply, LieHom.coe_toLinearMap, LieSubalgebra.coe_incl, LinearMap.coe_comp, LieSubalgebra.coe_bracket,
  Function.comp_apply]
[GOAL]
R : Type u
inst✝² : CommRing R
A : Type v
inst✝¹ : Ring A
inst✝ : Algebra R A
A' : Subalgebra R A
src✝ : (fun x => Submodule R A) A' := ↑Subalgebra.toSubmodule A'
x y : A
hx :
  x ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : A}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
hy :
  y ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : A}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
⊢ ⁅x, y⁆ ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : A}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
[PROOFSTEP]
change ⁅x, y⁆ ∈ A'
[GOAL]
R : Type u
inst✝² : CommRing R
A : Type v
inst✝¹ : Ring A
inst✝ : Algebra R A
A' : Subalgebra R A
src✝ : (fun x => Submodule R A) A' := ↑Subalgebra.toSubmodule A'
x y : A
hx :
  x ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : A}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
hy :
  y ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : A}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
⊢ ⁅x, y⁆ ∈ A'
[PROOFSTEP]
change x ∈ A' at hx
[GOAL]
R : Type u
inst✝² : CommRing R
A : Type v
inst✝¹ : Ring A
inst✝ : Algebra R A
A' : Subalgebra R A
src✝ : (fun x => Submodule R A) A' := ↑Subalgebra.toSubmodule A'
x y : A
hy :
  y ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : A}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
hx : x ∈ A'
⊢ ⁅x, y⁆ ∈ A'
[PROOFSTEP]
change y ∈ A' at hy
[GOAL]
R : Type u
inst✝² : CommRing R
A : Type v
inst✝¹ : Ring A
inst✝ : Algebra R A
A' : Subalgebra R A
src✝ : (fun x => Submodule R A) A' := ↑Subalgebra.toSubmodule A'
x y : A
hx : x ∈ A'
hy : y ∈ A'
⊢ ⁅x, y⁆ ∈ A'
[PROOFSTEP]
rw [LieRing.of_associative_ring_bracket]
[GOAL]
R : Type u
inst✝² : CommRing R
A : Type v
inst✝¹ : Ring A
inst✝ : Algebra R A
A' : Subalgebra R A
src✝ : (fun x => Submodule R A) A' := ↑Subalgebra.toSubmodule A'
x y : A
hx : x ∈ A'
hy : y ∈ A'
⊢ x * y - y * x ∈ A'
[PROOFSTEP]
have hxy := A'.mul_mem hx hy
[GOAL]
R : Type u
inst✝² : CommRing R
A : Type v
inst✝¹ : Ring A
inst✝ : Algebra R A
A' : Subalgebra R A
src✝ : (fun x => Submodule R A) A' := ↑Subalgebra.toSubmodule A'
x y : A
hx : x ∈ A'
hy : y ∈ A'
hxy : x * y ∈ A'
⊢ x * y - y * x ∈ A'
[PROOFSTEP]
have hyx := A'.mul_mem hy hx
[GOAL]
R : Type u
inst✝² : CommRing R
A : Type v
inst✝¹ : Ring A
inst✝ : Algebra R A
A' : Subalgebra R A
src✝ : (fun x => Submodule R A) A' := ↑Subalgebra.toSubmodule A'
x y : A
hx : x ∈ A'
hy : y ∈ A'
hxy : x * y ∈ A'
hyx : y * x ∈ A'
⊢ x * y - y * x ∈ A'
[PROOFSTEP]
exact Submodule.sub_mem (Subalgebra.toSubmodule A') hxy hyx
[GOAL]
R : Type u
M₁ : Type v
M₂ : Type w
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M₁
inst✝² : Module R M₁
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
e : M₁ ≃ₗ[R] M₂
src✝ : Module.End R M₁ ≃ₗ[R] Module.End R M₂ := conj e
f g : Module.End R M₁
⊢ ↑(conj e) ⁅f, g⁆ = ⁅↑(conj e) f, ↑(conj e) g⁆
[PROOFSTEP]
simp only [LieRing.of_associative_ring_bracket, LinearMap.mul_eq_comp, e.conj_comp, LinearEquiv.map_sub]
[GOAL]
R : Type u
A₁ : Type v
A₂ : Type w
inst✝⁴ : CommRing R
inst✝³ : Ring A₁
inst✝² : Ring A₂
inst✝¹ : Algebra R A₁
inst✝ : Algebra R A₂
e : A₁ ≃ₐ[R] A₂
src✝ : A₁ ≃ₗ[R] A₂ := toLinearEquiv e
x y : A₁
⊢ AddHom.toFun
      {
          toAddHom :=
            { toFun := e.toFun,
              map_add' :=
                (_ :
                  ∀ (x y : A₁),
                    AddHom.toFun src✝.toAddHom (x + y) = AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
          map_smul' :=
            (_ :
              ∀ (r : R) (x : A₁),
                AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
      ⁅x, y⁆ =
    ⁅AddHom.toFun
        {
            toAddHom :=
              { toFun := e.toFun,
                map_add' :=
                  (_ :
                    ∀ (x y : A₁),
                      AddHom.toFun src✝.toAddHom (x + y) =
                        AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
            map_smul' :=
              (_ :
                ∀ (r : R) (x : A₁),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        x,
      AddHom.toFun
        {
            toAddHom :=
              { toFun := e.toFun,
                map_add' :=
                  (_ :
                    ∀ (x y : A₁),
                      AddHom.toFun src✝.toAddHom (x + y) =
                        AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
            map_smul' :=
              (_ :
                ∀ (r : R) (x : A₁),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        y⁆
[PROOFSTEP]
have : e.toEquiv.toFun = e := rfl
[GOAL]
R : Type u
A₁ : Type v
A₂ : Type w
inst✝⁴ : CommRing R
inst✝³ : Ring A₁
inst✝² : Ring A₂
inst✝¹ : Algebra R A₁
inst✝ : Algebra R A₂
e : A₁ ≃ₐ[R] A₂
src✝ : A₁ ≃ₗ[R] A₂ := toLinearEquiv e
x y : A₁
this : e.toFun = ↑e
⊢ AddHom.toFun
      {
          toAddHom :=
            { toFun := e.toFun,
              map_add' :=
                (_ :
                  ∀ (x y : A₁),
                    AddHom.toFun src✝.toAddHom (x + y) = AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
          map_smul' :=
            (_ :
              ∀ (r : R) (x : A₁),
                AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
      ⁅x, y⁆ =
    ⁅AddHom.toFun
        {
            toAddHom :=
              { toFun := e.toFun,
                map_add' :=
                  (_ :
                    ∀ (x y : A₁),
                      AddHom.toFun src✝.toAddHom (x + y) =
                        AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
            map_smul' :=
              (_ :
                ∀ (r : R) (x : A₁),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        x,
      AddHom.toFun
        {
            toAddHom :=
              { toFun := e.toFun,
                map_add' :=
                  (_ :
                    ∀ (x y : A₁),
                      AddHom.toFun src✝.toAddHom (x + y) =
                        AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
            map_smul' :=
              (_ :
                ∀ (r : R) (x : A₁),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        y⁆
[PROOFSTEP]
simp_rw [LieRing.of_associative_ring_bracket, this, map_sub, map_mul]


[GOAL]
⊢ {x | Liouville x} = ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}
[PROOFSTEP]
ext x
[GOAL]
case h
x : ℝ
⊢ x ∈ {x | Liouville x} ↔ x ∈ ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}
[PROOFSTEP]
simp only [mem_iInter, mem_iUnion, Liouville, mem_setOf_eq, exists_prop, mem_diff, mem_singleton_iff, mem_ball,
  Real.dist_eq, and_comm]
[GOAL]
⊢ IsGδ {x | Liouville x}
[PROOFSTEP]
rw [setOf_liouville_eq_iInter_iUnion]
[GOAL]
⊢ IsGδ (⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b})
[PROOFSTEP]
refine isGδ_iInter fun n => IsOpen.isGδ ?_
[GOAL]
n : ℕ
⊢ IsOpen (⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b})
[PROOFSTEP]
refine isOpen_iUnion fun a => isOpen_iUnion fun b => isOpen_iUnion fun _hb => ?_
[GOAL]
n : ℕ
a b : ℤ
_hb : 1 < b
⊢ IsOpen (ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b})
[PROOFSTEP]
exact isOpen_ball.inter isClosed_singleton.isOpen_compl
[GOAL]
⊢ {x | Liouville x} = {x | Irrational x} ∩ ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)
[PROOFSTEP]
refine Subset.antisymm ?_ ?_
[GOAL]
case refine_1
⊢ {x | Liouville x} ⊆ {x | Irrational x} ∩ ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)
[PROOFSTEP]
refine subset_inter (fun x hx => hx.irrational) ?_
[GOAL]
case refine_1
⊢ {x | Liouville x} ⊆ ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)
[PROOFSTEP]
rw [setOf_liouville_eq_iInter_iUnion]
[GOAL]
case refine_1
⊢ ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b} ⊆
    ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)
[PROOFSTEP]
exact iInter_mono fun n => iUnion₂_mono fun a b => iUnion_mono fun _hb => diff_subset _ _
[GOAL]
case refine_2
⊢ {x | Irrational x} ∩ ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) ⊆ {x | Liouville x}
[PROOFSTEP]
simp only [inter_iInter, inter_iUnion, setOf_liouville_eq_iInter_iUnion]
[GOAL]
case refine_2
⊢ ⋂ (i : ℕ), ⋃ (i_1 : ℤ) (i_2 : ℤ) (_ : 1 < i_2), {x | Irrational x} ∩ ball (↑i_1 / ↑i_2) (1 / ↑i_2 ^ i) ⊆
    ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}
[PROOFSTEP]
refine iInter_mono fun n => iUnion₂_mono fun a b => iUnion_mono fun hb => ?_
[GOAL]
case refine_2
n : ℕ
a b : ℤ
hb : 1 < b
⊢ {x | Irrational x} ∩ ball (↑a / ↑b) (1 / ↑b ^ n) ⊆ ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}
[PROOFSTEP]
rw [inter_comm]
[GOAL]
case refine_2
n : ℕ
a b : ℤ
hb : 1 < b
⊢ ball (↑a / ↑b) (1 / ↑b ^ n) ∩ {x | Irrational x} ⊆ ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}
[PROOFSTEP]
exact diff_subset_diff Subset.rfl (singleton_subset_iff.2 ⟨a / b, by norm_cast⟩)
[GOAL]
n : ℕ
a b : ℤ
hb : 1 < b
⊢ ↑(↑a / ↑b) = ↑a / ↑b
[PROOFSTEP]
norm_cast
[GOAL]
⊢ ∀ᶠ (x : ℝ) in residual ℝ, Liouville x
[PROOFSTEP]
rw [Filter.Eventually, setOf_liouville_eq_irrational_inter_iInter_iUnion]
[GOAL]
⊢ {x | Irrational x} ∩ ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) ∈ residual ℝ
[PROOFSTEP]
refine eventually_residual_irrational.and ?_
[GOAL]
⊢ ∀ᶠ (x : ℝ) in residual ℝ, x ∈ ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)
[PROOFSTEP]
refine eventually_residual.2 ⟨_, ?_, Rat.denseEmbedding_coe_real.dense.mono ?_, Subset.rfl⟩
[GOAL]
case refine_1
⊢ IsGδ (⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n))
[PROOFSTEP]
exact
  isGδ_iInter fun n => IsOpen.isGδ <| isOpen_iUnion fun a => isOpen_iUnion fun b => isOpen_iUnion fun _hb => isOpen_ball
[GOAL]
case refine_2
⊢ range Rat.cast ⊆ ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)
[PROOFSTEP]
rintro _ ⟨r, rfl⟩
[GOAL]
case refine_2.intro
r : ℚ
⊢ ↑r ∈ ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)
[PROOFSTEP]
simp only [mem_iInter, mem_iUnion]
[GOAL]
case refine_2.intro
r : ℚ
⊢ ∀ (i : ℕ), ∃ i_1 i_2 i_3, ↑r ∈ ball (↑i_1 / ↑i_2) (1 / ↑i_2 ^ i)
[PROOFSTEP]
refine fun n => ⟨r.num * 2, r.den * 2, ?_, ?_⟩
[GOAL]
case refine_2.intro.refine_1
r : ℚ
n : ℕ
⊢ 1 < ↑r.den * 2
[PROOFSTEP]
have := Int.ofNat_le.2 r.pos
[GOAL]
case refine_2.intro.refine_1
r : ℚ
n : ℕ
this : ↑(Nat.succ 0) ≤ ↑r.den
⊢ 1 < ↑r.den * 2
[PROOFSTEP]
rw [Int.ofNat_one] at this
[GOAL]
case refine_2.intro.refine_1
r : ℚ
n : ℕ
this : 1 ≤ ↑r.den
⊢ 1 < ↑r.den * 2
[PROOFSTEP]
linarith
[GOAL]
case refine_2.intro.refine_2
r : ℚ
n : ℕ
⊢ ↑r ∈ ball (↑(r.num * 2) / ↑(↑r.den * 2)) (1 / ↑(↑r.den * 2) ^ n)
[PROOFSTEP]
convert @mem_ball_self ℝ _ (r : ℝ) _ _
[GOAL]
case h.e'_5.h.e'_3
r : ℚ
n : ℕ
⊢ ↑(r.num * 2) / ↑(↑r.den * 2) = ↑r
[PROOFSTEP]
push_cast
[GOAL]
case h.e'_5.h.e'_3
r : ℚ
n : ℕ
⊢ ↑r.num * 2 / (↑r.den * 2) = ↑r
[PROOFSTEP]
norm_cast
[GOAL]
case h.e'_5.h.e'_3
r : ℚ
n : ℕ
⊢ Rat.divInt (r.num * 2) ↑(r.den * 2) = r
[PROOFSTEP]
simp [Rat.divInt_mul_right (two_ne_zero), Rat.mkRat_self]
[GOAL]
case refine_2.intro.refine_2.convert_2
r : ℚ
n : ℕ
⊢ 0 < 1 / ↑(↑r.den * 2) ^ n
[PROOFSTEP]
refine' one_div_pos.2 (pow_pos (Int.cast_pos.2 _) _)
[GOAL]
case refine_2.intro.refine_2.convert_2
r : ℚ
n : ℕ
⊢ 0 < ↑r.den * 2
[PROOFSTEP]
exact mul_pos (Int.coe_nat_pos.2 r.pos) zero_lt_two


[GOAL]
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
⊢ restrictScalars F (normalClosure F K L) = ⨆ (x : K), adjoin F (rootSet (minpoly F x) L)
[PROOFSTEP]
classical
have hi : ∀ x : K, IsIntegral F x := fun x ↦ (isIntegral_algebraMap_iff (algebraMap K L).injective).mp (h.isIntegral _)
refine' le_antisymm (iSup_le _) (iSup_le fun x => adjoin_le_iff.mpr fun y hy => _)
· rintro f _ ⟨x, rfl⟩
  refine' le_iSup (fun x => adjoin F ((minpoly F x).rootSet L)) x (subset_adjoin F ((minpoly F x).rootSet L) _)
  rw [mem_rootSet_of_ne (minpoly.ne_zero (hi x)), AlgHom.toRingHom_eq_coe, AlgHom.coe_toRingHom,
    Polynomial.aeval_algHom_apply, minpoly.aeval, map_zero]
· rw [Polynomial.rootSet, Finset.mem_coe, Multiset.mem_toFinset] at hy
  let g := (algHomAdjoinIntegralEquiv F (hi x)).symm ⟨y, hy⟩
  refine'
    le_iSup (fun f : K →ₐ[F] L => f.fieldRange) ((g.liftNormal L).comp (toAlgHom F K L))
      ⟨x, (g.liftNormal_commutes L (AdjoinSimple.gen F x)).trans _⟩
  rw [Algebra.id.map_eq_id, RingHom.id_apply]
    -- Porting note: in mathlib3 this next `apply` closed the goal.
        -- Now it can't find a proof by unification, so we have to do it ourselves.
  apply PowerBasis.lift_gen
  change aeval y (minpoly F (AdjoinSimple.gen F x)) = 0
  exact minpoly_gen (hi x) ▸ aeval_eq_zero_of_mem_rootSet (Multiset.mem_toFinset.mpr hy)
[GOAL]
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
⊢ restrictScalars F (normalClosure F K L) = ⨆ (x : K), adjoin F (rootSet (minpoly F x) L)
[PROOFSTEP]
have hi : ∀ x : K, IsIntegral F x := fun x ↦ (isIntegral_algebraMap_iff (algebraMap K L).injective).mp (h.isIntegral _)
[GOAL]
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
hi : ∀ (x : K), IsIntegral F x
⊢ restrictScalars F (normalClosure F K L) = ⨆ (x : K), adjoin F (rootSet (minpoly F x) L)
[PROOFSTEP]
refine' le_antisymm (iSup_le _) (iSup_le fun x => adjoin_le_iff.mpr fun y hy => _)
[GOAL]
case refine'_1
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
hi : ∀ (x : K), IsIntegral F x
⊢ ∀ (i : K →ₐ[F] L), AlgHom.fieldRange i ≤ ⨆ (x : K), adjoin F (rootSet (minpoly F x) L)
[PROOFSTEP]
rintro f _ ⟨x, rfl⟩
[GOAL]
case refine'_1.intro
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
hi : ∀ (x : K), IsIntegral F x
f : K →ₐ[F] L
x : K
⊢ ↑↑f x ∈ ⨆ (x : K), adjoin F (rootSet (minpoly F x) L)
[PROOFSTEP]
refine' le_iSup (fun x => adjoin F ((minpoly F x).rootSet L)) x (subset_adjoin F ((minpoly F x).rootSet L) _)
[GOAL]
case refine'_1.intro
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
hi : ∀ (x : K), IsIntegral F x
f : K →ₐ[F] L
x : K
⊢ ↑↑f x ∈ rootSet (minpoly F x) L
[PROOFSTEP]
rw [mem_rootSet_of_ne (minpoly.ne_zero (hi x)), AlgHom.toRingHom_eq_coe, AlgHom.coe_toRingHom,
  Polynomial.aeval_algHom_apply, minpoly.aeval, map_zero]
[GOAL]
case refine'_2
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
hi : ∀ (x : K), IsIntegral F x
x : K
y : L
hy : y ∈ rootSet (minpoly F x) L
⊢ y ∈ ↑(restrictScalars F (normalClosure F K L))
[PROOFSTEP]
rw [Polynomial.rootSet, Finset.mem_coe, Multiset.mem_toFinset] at hy
[GOAL]
case refine'_2
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
hi : ∀ (x : K), IsIntegral F x
x : K
y : L
hy : y ∈ roots (Polynomial.map (algebraMap F L) (minpoly F x))
⊢ y ∈ ↑(restrictScalars F (normalClosure F K L))
[PROOFSTEP]
let g := (algHomAdjoinIntegralEquiv F (hi x)).symm ⟨y, hy⟩
[GOAL]
case refine'_2
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
hi : ∀ (x : K), IsIntegral F x
x : K
y : L
hy : y ∈ roots (Polynomial.map (algebraMap F L) (minpoly F x))
g : (fun x_1 => { x_2 // x_2 ∈ F⟮x⟯ } →ₐ[F] L) { val := y, property := hy } :=
  ↑(algHomAdjoinIntegralEquiv F (_ : IsIntegral F x)).symm { val := y, property := hy }
⊢ y ∈ ↑(restrictScalars F (normalClosure F K L))
[PROOFSTEP]
refine'
  le_iSup (fun f : K →ₐ[F] L => f.fieldRange) ((g.liftNormal L).comp (toAlgHom F K L))
    ⟨x, (g.liftNormal_commutes L (AdjoinSimple.gen F x)).trans _⟩
[GOAL]
case refine'_2
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
hi : ∀ (x : K), IsIntegral F x
x : K
y : L
hy : y ∈ roots (Polynomial.map (algebraMap F L) (minpoly F x))
g : (fun x_1 => { x_2 // x_2 ∈ F⟮x⟯ } →ₐ[F] L) { val := y, property := hy } :=
  ↑(algHomAdjoinIntegralEquiv F (_ : IsIntegral F x)).symm { val := y, property := hy }
⊢ ↑(algebraMap L L) (↑g (AdjoinSimple.gen F x)) = y
[PROOFSTEP]
rw [Algebra.id.map_eq_id, RingHom.id_apply]
  -- Porting note: in mathlib3 this next `apply` closed the goal.
      -- Now it can't find a proof by unification, so we have to do it ourselves.
[GOAL]
case refine'_2
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
hi : ∀ (x : K), IsIntegral F x
x : K
y : L
hy : y ∈ roots (Polynomial.map (algebraMap F L) (minpoly F x))
g : (fun x_1 => { x_2 // x_2 ∈ F⟮x⟯ } →ₐ[F] L) { val := y, property := hy } :=
  ↑(algHomAdjoinIntegralEquiv F (_ : IsIntegral F x)).symm { val := y, property := hy }
⊢ ↑g (AdjoinSimple.gen F x) = y
[PROOFSTEP]
apply PowerBasis.lift_gen
[GOAL]
case refine'_2.hy
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
hi : ∀ (x : K), IsIntegral F x
x : K
y : L
hy : y ∈ roots (Polynomial.map (algebraMap F L) (minpoly F x))
g : (fun x_1 => { x_2 // x_2 ∈ F⟮x⟯ } →ₐ[F] L) { val := y, property := hy } :=
  ↑(algHomAdjoinIntegralEquiv F (_ : IsIntegral F x)).symm { val := y, property := hy }
⊢ ↑(aeval
          ↑(↑(Equiv.subtypeEquiv (Equiv.refl L)
                    (_ :
                      ∀ (x_1 : L),
                        ↑(aeval x_1) (minpoly F (adjoin.powerBasis (_ : IsIntegral F x)).gen) = 0 ↔
                          ↑(Equiv.refl L) x_1 ∈
                            roots
                              (Polynomial.map (algebraMap F L)
                                (minpoly F (adjoin.powerBasis (_ : IsIntegral F x)).gen)))).symm
              (↑(Equiv.subtypeEquiv (Equiv.refl L)
                      (_ :
                        ∀ (x_1 : L),
                          x_1 ∈
                              roots
                                (Polynomial.map (algebraMap F L)
                                  (minpoly F (adjoin.powerBasis (_ : IsIntegral F x)).gen)) ↔
                            ↑(Equiv.refl L) x_1 ∈ roots (Polynomial.map (algebraMap F L) (minpoly F x)))).symm
                { val := y, property := hy })))
      (minpoly F (adjoin.powerBasis (_ : IsIntegral F x)).gen) =
    0
[PROOFSTEP]
change aeval y (minpoly F (AdjoinSimple.gen F x)) = 0
[GOAL]
case refine'_2.hy
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
hi : ∀ (x : K), IsIntegral F x
x : K
y : L
hy : y ∈ roots (Polynomial.map (algebraMap F L) (minpoly F x))
g : (fun x_1 => { x_2 // x_2 ∈ F⟮x⟯ } →ₐ[F] L) { val := y, property := hy } :=
  ↑(algHomAdjoinIntegralEquiv F (_ : IsIntegral F x)).symm { val := y, property := hy }
⊢ ↑(aeval y) (minpoly F (AdjoinSimple.gen F x)) = 0
[PROOFSTEP]
exact minpoly_gen (hi x) ▸ aeval_eq_zero_of_mem_rootSet (Multiset.mem_toFinset.mpr hy)
[GOAL]
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
⊢ Normal F { x // x ∈ normalClosure F K L }
[PROOFSTEP]
let ϕ := algebraMap K L
[GOAL]
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
ϕ : K →+* L := algebraMap K L
⊢ Normal F { x // x ∈ normalClosure F K L }
[PROOFSTEP]
rw [← IntermediateField.restrictScalars_normal, restrictScalars_eq_iSup_adjoin]
  -- Porting note: use the `(_)` trick to obtain an instance by unification.
[GOAL]
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
ϕ : K →+* L := algebraMap K L
⊢ Normal F { x // x ∈ ⨆ (x : K), adjoin F (rootSet (minpoly F x) L) }
[PROOFSTEP]
apply IntermediateField.normal_iSup (h := _)
[GOAL]
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
ϕ : K →+* L := algebraMap K L
⊢ ∀ (i : K), Normal F { x // x ∈ adjoin F (rootSet (minpoly F i) L) }
[PROOFSTEP]
intro x
[GOAL]
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
ϕ : K →+* L := algebraMap K L
x : K
⊢ Normal F { x_1 // x_1 ∈ adjoin F (rootSet (minpoly F x) L) }
[PROOFSTEP]
apply Normal.of_isSplittingField (p := minpoly F x) (hFEp := _)
[GOAL]
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra F K
inst✝² : Algebra F L
inst✝¹ : Algebra K L
inst✝ : IsScalarTower F K L
h : Normal F L
ϕ : K →+* L := algebraMap K L
x : K
⊢ IsSplittingField F { x_1 // x_1 ∈ adjoin F (rootSet (minpoly F x) L) } (minpoly F x)
[PROOFSTEP]
exact
  adjoin_rootSet_isSplittingField
    ((minpoly.eq_of_algebraMap_eq ϕ.injective ((isIntegral_algebraMap_iff ϕ.injective).mp (h.isIntegral (ϕ x)))
          rfl).symm ▸
      h.splits _)
[GOAL]
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁷ : Field F
inst✝⁶ : Field K
inst✝⁵ : Field L
inst✝⁴ : Algebra F K
inst✝³ : Algebra F L
inst✝² : Algebra K L
inst✝¹ : IsScalarTower F K L
inst✝ : FiniteDimensional F K
⊢ FiniteDimensional F { x // x ∈ normalClosure F K L }
[PROOFSTEP]
haveI : ∀ f : K →ₐ[F] L, FiniteDimensional F f.fieldRange := fun f => f.toLinearMap.finiteDimensional_range
[GOAL]
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁷ : Field F
inst✝⁶ : Field K
inst✝⁵ : Field L
inst✝⁴ : Algebra F K
inst✝³ : Algebra F L
inst✝² : Algebra K L
inst✝¹ : IsScalarTower F K L
inst✝ : FiniteDimensional F K
this : ∀ (f : K →ₐ[F] L), FiniteDimensional F { x // x ∈ AlgHom.fieldRange f }
⊢ FiniteDimensional F { x // x ∈ normalClosure F K L }
[PROOFSTEP]
apply IntermediateField.finiteDimensional_iSup_of_finite


[GOAL]
X : Type u_1
inst✝ : EMetricSpace X
s t : Set X
x✝ y : X
h : IsMetricSeparated s t
r : ENNReal
r0 : r ≠ 0
hr : ∀ (x : X), x ∈ s → ∀ (y : X), y ∈ t → r ≤ edist x y
x : X
hx1 : x ∈ s
hx2 : x ∈ t
⊢ r = 0
[PROOFSTEP]
simpa using hr x hx1 x hx2
[GOAL]
X : Type u_1
inst✝ : EMetricSpace X
s t : Set X
x y : X
s' : Set X
h : IsMetricSeparated s t
h' : IsMetricSeparated s' t
⊢ IsMetricSeparated (s ∪ s') t
[PROOFSTEP]
rcases h, h' with ⟨⟨r, r0, hr⟩, ⟨r', r0', hr'⟩⟩
[GOAL]
case intro.intro.intro.intro
X : Type u_1
inst✝ : EMetricSpace X
s t : Set X
x y : X
s' : Set X
r : ENNReal
r0 : r ≠ 0
hr : ∀ (x : X), x ∈ s → ∀ (y : X), y ∈ t → r ≤ edist x y
r' : ENNReal
r0' : r' ≠ 0
hr' : ∀ (x : X), x ∈ s' → ∀ (y : X), y ∈ t → r' ≤ edist x y
⊢ IsMetricSeparated (s ∪ s') t
[PROOFSTEP]
refine' ⟨min r r', _, fun x hx y hy => hx.elim _ _⟩
[GOAL]
case intro.intro.intro.intro.refine'_1
X : Type u_1
inst✝ : EMetricSpace X
s t : Set X
x y : X
s' : Set X
r : ENNReal
r0 : r ≠ 0
hr : ∀ (x : X), x ∈ s → ∀ (y : X), y ∈ t → r ≤ edist x y
r' : ENNReal
r0' : r' ≠ 0
hr' : ∀ (x : X), x ∈ s' → ∀ (y : X), y ∈ t → r' ≤ edist x y
⊢ min r r' ≠ 0
[PROOFSTEP]
rw [← pos_iff_ne_zero] at r0 r0' ⊢
[GOAL]
case intro.intro.intro.intro.refine'_1
X : Type u_1
inst✝ : EMetricSpace X
s t : Set X
x y : X
s' : Set X
r : ENNReal
r0 : 0 < r
hr : ∀ (x : X), x ∈ s → ∀ (y : X), y ∈ t → r ≤ edist x y
r' : ENNReal
r0' : 0 < r'
hr' : ∀ (x : X), x ∈ s' → ∀ (y : X), y ∈ t → r' ≤ edist x y
⊢ 0 < min r r'
[PROOFSTEP]
exact lt_min r0 r0'
[GOAL]
case intro.intro.intro.intro.refine'_2
X : Type u_1
inst✝ : EMetricSpace X
s t : Set X
x✝ y✝ : X
s' : Set X
r : ENNReal
r0 : r ≠ 0
hr : ∀ (x : X), x ∈ s → ∀ (y : X), y ∈ t → r ≤ edist x y
r' : ENNReal
r0' : r' ≠ 0
hr' : ∀ (x : X), x ∈ s' → ∀ (y : X), y ∈ t → r' ≤ edist x y
x : X
hx : x ∈ s ∪ s'
y : X
hy : y ∈ t
⊢ x ∈ s → min r r' ≤ edist x y
[PROOFSTEP]
exact fun hx => (min_le_left _ _).trans (hr _ hx _ hy)
[GOAL]
case intro.intro.intro.intro.refine'_3
X : Type u_1
inst✝ : EMetricSpace X
s t : Set X
x✝ y✝ : X
s' : Set X
r : ENNReal
r0 : r ≠ 0
hr : ∀ (x : X), x ∈ s → ∀ (y : X), y ∈ t → r ≤ edist x y
r' : ENNReal
r0' : r' ≠ 0
hr' : ∀ (x : X), x ∈ s' → ∀ (y : X), y ∈ t → r' ≤ edist x y
x : X
hx : x ∈ s ∪ s'
y : X
hy : y ∈ t
⊢ x ∈ s' → min r r' ≤ edist x y
[PROOFSTEP]
exact fun hx => (min_le_right _ _).trans (hr' _ hx _ hy)
[GOAL]
X : Type u_1
inst✝ : EMetricSpace X
s✝ t✝ : Set X
x y : X
ι : Type u_2
I : Set ι
hI : Set.Finite I
s : ι → Set X
t : Set X
⊢ IsMetricSeparated (⋃ (i : ι) (_ : i ∈ I), s i) t ↔ ∀ (i : ι), i ∈ I → IsMetricSeparated (s i) t
[PROOFSTEP]
refine' Finite.induction_on hI (by simp) @fun i I _ _ hI => _
[GOAL]
X : Type u_1
inst✝ : EMetricSpace X
s✝ t✝ : Set X
x y : X
ι : Type u_2
I : Set ι
hI : Set.Finite I
s : ι → Set X
t : Set X
⊢ IsMetricSeparated (⋃ (i : ι) (_ : i ∈ ∅), s i) t ↔ ∀ (i : ι), i ∈ ∅ → IsMetricSeparated (s i) t
[PROOFSTEP]
simp
[GOAL]
X : Type u_1
inst✝ : EMetricSpace X
s✝ t✝ : Set X
x y : X
ι : Type u_2
I✝ : Set ι
hI✝ : Set.Finite I✝
s : ι → Set X
t : Set X
i : ι
I : Set ι
x✝¹ : ¬i ∈ I
x✝ : Set.Finite I
hI : IsMetricSeparated (⋃ (i : ι) (_ : i ∈ I), s i) t ↔ ∀ (i : ι), i ∈ I → IsMetricSeparated (s i) t
⊢ IsMetricSeparated (⋃ (i_1 : ι) (_ : i_1 ∈ insert i I), s i_1) t ↔
    ∀ (i_1 : ι), i_1 ∈ insert i I → IsMetricSeparated (s i_1) t
[PROOFSTEP]
rw [biUnion_insert, ball_insert_iff, union_left_iff, hI]
[GOAL]
X : Type u_1
inst✝ : EMetricSpace X
s✝ t✝ : Set X
x y : X
ι : Type u_2
I : Set ι
hI : Set.Finite I
s : Set X
t : ι → Set X
⊢ IsMetricSeparated s (⋃ (i : ι) (_ : i ∈ I), t i) ↔ ∀ (i : ι), i ∈ I → IsMetricSeparated s (t i)
[PROOFSTEP]
simpa only [@comm _ _ s] using finite_iUnion_left_iff hI


[GOAL]
A : Type u₁
B : Type u₂
inst✝⁷ : Category.{v₁, u₁} A
inst✝⁶ : Category.{v₂, u₂} B
inst✝⁵ : HasEqualizers A
inst✝⁴ : HasImages A
inst✝³ : StrongEpiCategory B
inst✝² : HasImages B
L : A ⥤ B
inst✝¹ : {X Y Z : A} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PreservesLimit (cospan f g) L
inst✝ : {X Y Z : A} → (f : X ⟶ Y) → (g : X ⟶ Z) → PreservesColimit (span f g) L
X Y : A
f : X ⟶ Y
⊢ L.map (factorThruImage f) ≫ L.map (image.ι f) = L.map f
[PROOFSTEP]
rw [← L.map_comp, Limits.image.fac]
[GOAL]
A : Type u₁
B : Type u₂
inst✝⁷ : Category.{v₁, u₁} A
inst✝⁶ : Category.{v₂, u₂} B
inst✝⁵ : HasEqualizers A
inst✝⁴ : HasImages A
inst✝³ : StrongEpiCategory B
inst✝² : HasImages B
L : A ⥤ B
inst✝¹ : {X Y Z : A} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PreservesLimit (cospan f g) L
inst✝ : {X Y Z : A} → (f : X ⟶ Y) → (g : X ⟶ Z) → PreservesColimit (span f g) L
X Y : A
f : X ⟶ Y
⊢ factorThruImage (L.map f) ≫ (iso L f).hom = L.map (factorThruImage f)
[PROOFSTEP]
simp
[GOAL]
A : Type u₁
B : Type u₂
inst✝⁷ : Category.{v₁, u₁} A
inst✝⁶ : Category.{v₂, u₂} B
inst✝⁵ : HasEqualizers A
inst✝⁴ : HasImages A
inst✝³ : StrongEpiCategory B
inst✝² : HasImages B
L : A ⥤ B
inst✝¹ : {X Y Z : A} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PreservesLimit (cospan f g) L
inst✝ : {X Y Z : A} → (f : X ⟶ Y) → (g : X ⟶ Z) → PreservesColimit (span f g) L
X Y : A
f : X ⟶ Y
⊢ (iso L f).hom ≫ L.map (image.ι f) = image.ι (L.map f)
[PROOFSTEP]
rw [iso_hom, image.lift_fac]
[GOAL]
A : Type u₁
B : Type u₂
inst✝⁷ : Category.{v₁, u₁} A
inst✝⁶ : Category.{v₂, u₂} B
inst✝⁵ : HasEqualizers A
inst✝⁴ : HasImages A
inst✝³ : StrongEpiCategory B
inst✝² : HasImages B
L : A ⥤ B
inst✝¹ : {X Y Z : A} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PreservesLimit (cospan f g) L
inst✝ : {X Y Z : A} → (f : X ⟶ Y) → (g : X ⟶ Z) → PreservesColimit (span f g) L
X Y : A
f : X ⟶ Y
⊢ (iso L f).inv ≫ image.ι (L.map f) = L.map (image.ι f)
[PROOFSTEP]
simp


[GOAL]
E : Type u_1
X : Type u_2
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalSpace X
f : E → X
s : Set X
x : E
I : Type u_3
inst✝ : TopologicalSpace I
h✝ : IsEvenlyCovered f (f x) I
e : Trivialization I f := Classical.choose (_ : ∃ t, f x ∈ t.baseSet)
h : f x ∈ (Classical.choose (_ : ∃ t, f x ∈ t.baseSet)).baseSet := Classical.choose_spec h✝.right
he : (f x, (↑e x).snd) = ↑e x := Trivialization.mk_proj_snd' e h
⊢ (f x, (↑e x).snd) ∈ e.target
[PROOFSTEP]
rwa [he, e.mem_target, e.coe_fst (e.mem_source.mpr h)]
[GOAL]
E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
hf : IsCoveringMapOn f s
⊢ IsLocallyHomeomorphOn f (f ⁻¹' s)
[PROOFSTEP]
refine' IsLocallyHomeomorphOn.mk f (f ⁻¹' s) fun x hx => _
[GOAL]
E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
hf : IsCoveringMapOn f s
x : E
hx : x ∈ f ⁻¹' s
⊢ ∃ e, x ∈ e.source ∧ ∀ (y : E), y ∈ e.source → f y = ↑e y
[PROOFSTEP]
let e := (hf (f x) hx).toTrivialization
[GOAL]
E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
hf : IsCoveringMapOn f s
x : E
hx : x ∈ f ⁻¹' s
e : Trivialization (↑(f ⁻¹' {f x})) f := IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))
⊢ ∃ e, x ∈ e.source ∧ ∀ (y : E), y ∈ e.source → f y = ↑e y
[PROOFSTEP]
have h := (hf (f x) hx).mem_toTrivialization_baseSet
[GOAL]
E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
hf : IsCoveringMapOn f s
x : E
hx : x ∈ f ⁻¹' s
e : Trivialization (↑(f ⁻¹' {f x})) f := IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))
h : f x ∈ (IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))).baseSet
⊢ ∃ e, x ∈ e.source ∧ ∀ (y : E), y ∈ e.source → f y = ↑e y
[PROOFSTEP]
let he := e.mem_source.2 h
[GOAL]
E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
hf : IsCoveringMapOn f s
x : E
hx : x ∈ f ⁻¹' s
e : Trivialization (↑(f ⁻¹' {f x})) f := IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))
h : f x ∈ (IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))).baseSet
he : x ∈ e.source := Iff.mpr (Trivialization.mem_source e) h
⊢ ∃ e, x ∈ e.source ∧ ∀ (y : E), y ∈ e.source → f y = ↑e y
[PROOFSTEP]
refine'
  ⟨e.toLocalHomeomorph.trans
      { toFun := fun p => p.1
        invFun := fun p => ⟨p, x, rfl⟩
        source := e.baseSet ×ˢ ({⟨x, rfl⟩} : Set (f ⁻¹' {f x}))
        target := e.baseSet
        open_source := e.open_baseSet.prod (singletons_open_iff_discrete.2 (hf (f x) hx).1 ⟨x, rfl⟩)
        open_target := e.open_baseSet
        map_source' := fun p => And.left
        map_target' := fun p hp => ⟨hp, rfl⟩
        left_inv' := fun p hp => Prod.ext rfl hp.2.symm
        right_inv' := fun p _ => rfl
        continuous_toFun := continuous_fst.continuousOn
        continuous_invFun := (continuous_id'.prod_mk continuous_const).continuousOn },
    ⟨he, by rwa [e.toLocalHomeomorph.symm_symm, e.proj_toFun x he], (hf (f x) hx).toTrivialization_apply⟩, fun p h =>
    (e.proj_toFun p h.1).symm⟩
[GOAL]
E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
hf : IsCoveringMapOn f s
x : E
hx : x ∈ f ⁻¹' s
e : Trivialization (↑(f ⁻¹' {f x})) f := IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))
h : f x ∈ (IsEvenlyCovered.toTrivialization (_ : IsEvenlyCovered f (f x) ↑(f ⁻¹' {f x}))).baseSet
he : x ∈ e.source := Iff.mpr (Trivialization.mem_source e) h
⊢ (↑(LocalHomeomorph.symm (LocalHomeomorph.symm e.toLocalHomeomorph)) x).fst ∈ e.baseSet
[PROOFSTEP]
rwa [e.toLocalHomeomorph.symm_symm, e.proj_toFun x he]
[GOAL]
E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
⊢ IsCoveringMap f ↔ IsCoveringMapOn f Set.univ
[PROOFSTEP]
simp only [IsCoveringMap, IsCoveringMapOn, Set.mem_univ, forall_true_left]