[GOAL]
J : Type v
inst✝ : SmallCategory J
F : J ⥤ GroupCatMax
j : J
⊢ Group ((F ⋙ forget GroupCat).obj j)
[PROOFSTEP]
change Group (F.obj j)
[GOAL]
J : Type v
inst✝ : SmallCategory J
F : J ⥤ GroupCatMax
j : J
⊢ Group ↑(F.obj j)
[PROOFSTEP]
infer_instance
[GOAL]
J : Type v
inst✝ : SmallCategory J
F : J ⥤ GroupCat
src✝ : Submonoid ((j : J) → ↑((F ⋙ forget₂ GroupCat MonCat).obj j)) :=
  MonCat.sectionsSubmonoid (F ⋙ forget₂ GroupCat MonCat)
a : (j : J) → ↑(F.obj j)
ah :
  a ∈
    {
          toSubsemigroup :=
            { carrier := Functor.sections (F ⋙ forget GroupCat),
              mul_mem' :=
                (_ : ∀ {a b : (j : J) → ↑(F.obj j)}, a ∈ src✝.carrier → b ∈ src✝.carrier → a * b ∈ src✝.carrier) },
          one_mem' :=
            (_ :
              ∀ {j j' : J} (f : j ⟶ j'),
                ((F ⋙ forget₂ GroupCat MonCat) ⋙ forget MonCat).map f (OfNat.ofNat 1 j) =
                  OfNat.ofNat 1 j') }.toSubsemigroup.carrier
j j' : J
f : j ⟶ j'
⊢ (F ⋙ forget GroupCat).map f (a⁻¹ j) = a⁻¹ j'
[PROOFSTEP]
simp only [Functor.comp_map, Pi.inv_apply, MonoidHom.map_inv, inv_inj]
[GOAL]
J : Type v
inst✝ : SmallCategory J
F : J ⥤ GroupCat
src✝ : Submonoid ((j : J) → ↑((F ⋙ forget₂ GroupCat MonCat).obj j)) :=
  MonCat.sectionsSubmonoid (F ⋙ forget₂ GroupCat MonCat)
a : (j : J) → ↑(F.obj j)
ah :
  a ∈
    {
          toSubsemigroup :=
            { carrier := Functor.sections (F ⋙ forget GroupCat),
              mul_mem' :=
                (_ : ∀ {a b : (j : J) → ↑(F.obj j)}, a ∈ src✝.carrier → b ∈ src✝.carrier → a * b ∈ src✝.carrier) },
          one_mem' :=
            (_ :
              ∀ {j j' : J} (f : j ⟶ j'),
                ((F ⋙ forget₂ GroupCat MonCat) ⋙ forget MonCat).map f (OfNat.ofNat 1 j) =
                  OfNat.ofNat 1 j') }.toSubsemigroup.carrier
j j' : J
f : j ⟶ j'
⊢ (forget GroupCat).map (F.map f) (a j)⁻¹ = (a j')⁻¹
[PROOFSTEP]
dsimp [Functor.sections] at ah ⊢
[GOAL]
J : Type v
inst✝ : SmallCategory J
F : J ⥤ GroupCat
src✝ : Submonoid ((j : J) → ↑((F ⋙ forget₂ GroupCat MonCat).obj j)) :=
  MonCat.sectionsSubmonoid (F ⋙ forget₂ GroupCat MonCat)
a : (j : J) → ↑(F.obj j)
ah : a ∈ {u | ∀ {j j' : J} (f : j ⟶ j'), ↑(F.map f) (u j) = u j'}
j j' : J
f : j ⟶ j'
⊢ ↑(F.map f) (a j)⁻¹ = (a j')⁻¹
[PROOFSTEP]
rw [(F.map f).map_inv (a j), ah f]
[GOAL]
J : Type v
inst✝ : SmallCategory J
F : J ⥤ GroupCatMax
⊢ Group (Types.limitCone (F ⋙ forget GroupCat)).pt
[PROOFSTEP]
change Group (sectionsSubgroup.{v, u} F)
[GOAL]
J : Type v
inst✝ : SmallCategory J
F : J ⥤ GroupCatMax
⊢ Group { x // x ∈ sectionsSubgroup F }
[PROOFSTEP]
infer_instance
[GOAL]
J : Type v
inst✝ : SmallCategory J
F : J ⥤ GroupCatMax
this : ReflectsIsomorphisms (forget₂ GroupCatMax MonCatMax) := reflectsIsomorphisms_forget₂ GroupCatMax MonCatMax
c' : Cone (F ⋙ forget₂ GroupCat MonCat)
t : IsLimit c'
⊢ (forget₂ GroupCat MonCat).mapCone
      { pt := of (Types.limitCone (F ⋙ forget GroupCatMax)).pt,
        π := NatTrans.mk (MonCat.limitπMonoidHom (F ⋙ forget₂ GroupCatMax MonCatMax)) } ≅
    c'
[PROOFSTEP]
apply IsLimit.uniqueUpToIso (MonCat.HasLimits.limitConeIsLimit.{v, u} _) t
[GOAL]
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CommGroupCatMax
j : J
⊢ CommGroup ((F ⋙ forget CommGroupCatMax).obj j)
[PROOFSTEP]
change CommGroup (F.obj j)
[GOAL]
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CommGroupCatMax
j : J
⊢ CommGroup ↑(F.obj j)
[PROOFSTEP]
infer_instance
[GOAL]
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CommGroupCatMax
this : ReflectsIsomorphisms (forget₂ CommGroupCatMax GroupCatMax) :=
  reflectsIsomorphisms_forget₂ CommGroupCatMax GroupCatMax
c' : Cone (F ⋙ forget₂ CommGroupCat GroupCatMax)
t : IsLimit c'
⊢ (forget₂ CommGroupCat GroupCatMax).mapCone
      { pt := of (Types.limitCone (F ⋙ forget CommGroupCat)).pt,
        π := NatTrans.mk (MonCat.limitπMonoidHom (F ⋙ forget₂ CommGroupCat GroupCat ⋙ forget₂ GroupCat MonCat)) } ≅
    c'
[PROOFSTEP]
apply IsLimit.uniqueUpToIso (GroupCat.limitConeIsLimit _) t
[GOAL]
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CommGroupCatMax
this : ReflectsIsomorphisms (forget₂ CommGroupCatMax GroupCatMax) :=
  reflectsIsomorphisms_forget₂ CommGroupCatMax GroupCatMax
c' : Cone (F ⋙ forget₂ CommGroupCat GroupCatMax)
t : IsLimit c'
⊢ IsLimit
    ((forget₂ CommGroupCatMax GroupCat ⋙ forget₂ GroupCat MonCat).mapCone
      {
          liftedCone :=
            { pt := of (Types.limitCone (F ⋙ forget CommGroupCat)).pt,
              π := NatTrans.mk (MonCat.limitπMonoidHom (F ⋙ forget₂ CommGroupCat GroupCat ⋙ forget₂ GroupCat MonCat)) },
          validLift :=
            IsLimit.uniqueUpToIso (GroupCat.limitConeIsLimit (F ⋙ forget₂ CommGroupCat GroupCatMax)) t }.liftedCone)
[PROOFSTEP]
apply MonCat.HasLimits.limitConeIsLimit _
[GOAL]
J✝ : Type v
inst✝ : SmallCategory J✝
J : Type v
𝒥 : Category.{v, v} J
F : J ⥤ CommGroupCatMax
⊢ PreservesLimit F (forget₂ CommGroupCatMax GroupCatMax)
[PROOFSTEP]
infer_instance
[GOAL]
J : Type v
inst✝ : SmallCategory J
f : ℕ → AddCommGroupCat
⊢ HasProduct f
[PROOFSTEP]
infer_instance
[GOAL]
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
⊢ (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0
[PROOFSTEP]
refine Subtype.ext ?_
[GOAL]
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
⊢ ↑((fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0) = ↑0
[PROOFSTEP]
simp [(AddSubgroup.coe_zero _).symm]
[GOAL]
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
g g' : ↑(kernel f)
⊢ ZeroHom.toFun
      { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
        map_zero' := (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
      (g + g') =
    ZeroHom.toFun
        { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
          map_zero' := (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
        g +
      ZeroHom.toFun
        { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
          map_zero' := (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
        g'
[PROOFSTEP]
refine Subtype.ext ?_
[GOAL]
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
g g' : ↑(kernel f)
⊢ ↑(ZeroHom.toFun
        { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
          map_zero' := (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
        (g + g')) =
    ↑(ZeroHom.toFun
          { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
            map_zero' :=
              (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
          g +
        ZeroHom.toFun
          { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
            map_zero' :=
              (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
          g')
[PROOFSTEP]
change _ = _ + _
[GOAL]
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
g g' : ↑(kernel f)
⊢ ↑(ZeroHom.toFun
        { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
          map_zero' := (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
        (g + g')) =
    ↑(ZeroHom.toFun
          { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
            map_zero' :=
              (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
          g) +
      ↑(ZeroHom.toFun
          { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
            map_zero' :=
              (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
          g')
[PROOFSTEP]
dsimp
[GOAL]
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
g g' : ↑(kernel f)
⊢ ↑(kernel.ι f) (g + g') = ↑(kernel.ι f) g + ↑(kernel.ι f) g'
[PROOFSTEP]
simp
[GOAL]
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
⊢ AddSubgroup.subtype (AddMonoidHom.ker f) ≫ f = 0
[PROOFSTEP]
refine FunLike.ext _ _ ?_
[GOAL]
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
⊢ ∀ (x : ↑(of { x // x ∈ AddMonoidHom.ker f })), ↑(AddSubgroup.subtype (AddMonoidHom.ker f) ≫ f) x = ↑0 x
[PROOFSTEP]
rintro ⟨x, (hx : f _ = 0)⟩
[GOAL]
case mk
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
x : ↑G
hx : ↑f x = 0
⊢ ↑(AddSubgroup.subtype (AddMonoidHom.ker f) ≫ f) { val := x, property := hx } = ↑0 { val := x, property := hx }
[PROOFSTEP]
exact hx
[GOAL]
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
⊢ {
        toZeroHom :=
          { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
            map_zero' :=
              (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) },
        map_add' :=
          (_ :
            ∀ (g g' : ↑(kernel f)),
              ZeroHom.toFun
                  { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
                    map_zero' :=
                      (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
                  (g + g') =
                ZeroHom.toFun
                    { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
                      map_zero' :=
                        (_ :
                          (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
                    g +
                  ZeroHom.toFun
                    { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
                      map_zero' :=
                        (_ :
                          (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
                    g') } ≫
      kernel.lift f (AddSubgroup.subtype (AddMonoidHom.ker f)) (_ : AddSubgroup.subtype (AddMonoidHom.ker f) ≫ f = 0) =
    𝟙 (kernel f)
[PROOFSTEP]
refine equalizer.hom_ext ?_
[GOAL]
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
⊢ ({
          toZeroHom :=
            { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
              map_zero' :=
                (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) },
          map_add' :=
            (_ :
              ∀ (g g' : ↑(kernel f)),
                ZeroHom.toFun
                    { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
                      map_zero' :=
                        (_ :
                          (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
                    (g + g') =
                  ZeroHom.toFun
                      { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
                        map_zero' :=
                          (_ :
                            (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
                      g +
                    ZeroHom.toFun
                      { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
                        map_zero' :=
                          (_ :
                            (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
                      g') } ≫
        kernel.lift f (AddSubgroup.subtype (AddMonoidHom.ker f))
          (_ : AddSubgroup.subtype (AddMonoidHom.ker f) ≫ f = 0)) ≫
      equalizer.ι f 0 =
    𝟙 (kernel f) ≫ equalizer.ι f 0
[PROOFSTEP]
ext x
[GOAL]
case w
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
x : ↑(kernel f)
⊢ ↑(({
              toZeroHom :=
                { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
                  map_zero' :=
                    (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) },
              map_add' :=
                (_ :
                  ∀ (g g' : ↑(kernel f)),
                    ZeroHom.toFun
                        { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
                          map_zero' :=
                            (_ :
                              (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 =
                                0) }
                        (g + g') =
                      ZeroHom.toFun
                          { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
                            map_zero' :=
                              (_ :
                                (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 =
                                  0) }
                          g +
                        ZeroHom.toFun
                          { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
                            map_zero' :=
                              (_ :
                                (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 =
                                  0) }
                          g') } ≫
            kernel.lift f (AddSubgroup.subtype (AddMonoidHom.ker f))
              (_ : AddSubgroup.subtype (AddMonoidHom.ker f) ≫ f = 0)) ≫
          equalizer.ι f 0)
      x =
    ↑(𝟙 (kernel f) ≫ equalizer.ι f 0) x
[PROOFSTEP]
dsimp
[GOAL]
case w
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
x : ↑(kernel f)
⊢ ↑(kernel.ι f)
      (↑(kernel.lift f (AddSubgroup.subtype (AddMonoidHom.ker f))
            (_ : AddSubgroup.subtype (AddMonoidHom.ker f) ≫ f = 0))
        { val := ↑(kernel.ι f) x, property := (_ : ↑(kernel.ι f ≫ f) x = ↑0 x) }) =
    ↑(kernel.ι f) x
[PROOFSTEP]
generalize_proofs _ h1 h2
[GOAL]
case w
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
x : ↑(kernel f)
h✝ : HasKernel f
h1 : AddSubgroup.subtype (AddMonoidHom.ker f) ≫ f = 0
h2 : ↑(kernel.ι f ≫ f) x = ↑0 x
⊢ ↑(kernel.ι f)
      (↑(kernel.lift f (AddSubgroup.subtype (AddMonoidHom.ker f)) h1) { val := ↑(kernel.ι f) x, property := h2 }) =
    ↑(kernel.ι f) x
[PROOFSTEP]
erw [FunLike.congr_fun (kernel.lift_ι f _ h1) ⟨_, h2⟩]
[GOAL]
case w
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
x : ↑(kernel f)
h✝ : HasKernel f
h1 : AddSubgroup.subtype (AddMonoidHom.ker f) ≫ f = 0
h2 : ↑(kernel.ι f ≫ f) x = ↑0 x
⊢ ↑(AddSubgroup.subtype (AddMonoidHom.ker f)) { val := ↑(kernel.ι f) x, property := h2 } = ↑(kernel.ι f) x
[PROOFSTEP]
rfl
[GOAL]
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
⊢ kernel.lift f (AddSubgroup.subtype (AddMonoidHom.ker f)) (_ : AddSubgroup.subtype (AddMonoidHom.ker f) ≫ f = 0) ≫
      {
        toZeroHom :=
          { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
            map_zero' :=
              (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) },
        map_add' :=
          (_ :
            ∀ (g g' : ↑(kernel f)),
              ZeroHom.toFun
                  { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
                    map_zero' :=
                      (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
                  (g + g') =
                ZeroHom.toFun
                    { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
                      map_zero' :=
                        (_ :
                          (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
                    g +
                  ZeroHom.toFun
                    { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
                      map_zero' :=
                        (_ :
                          (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) }
                    g') } =
    𝟙 (of { x // x ∈ AddMonoidHom.ker f })
[PROOFSTEP]
apply AddCommGroupCat.ext
[GOAL]
case w
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
⊢ ∀ (x : ↑(of { x // x ∈ AddMonoidHom.ker f })),
    ↑(kernel.lift f (AddSubgroup.subtype (AddMonoidHom.ker f)) (_ : AddSubgroup.subtype (AddMonoidHom.ker f) ≫ f = 0) ≫
            {
              toZeroHom :=
                { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
                  map_zero' :=
                    (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) },
              map_add' :=
                (_ :
                  ∀ (g g' : ↑(kernel f)),
                    ZeroHom.toFun
                        { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
                          map_zero' :=
                            (_ :
                              (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 =
                                0) }
                        (g + g') =
                      ZeroHom.toFun
                          { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
                            map_zero' :=
                              (_ :
                                (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 =
                                  0) }
                          g +
                        ZeroHom.toFun
                          { toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
                            map_zero' :=
                              (_ :
                                (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 =
                                  0) }
                          g') })
        x =
      ↑(𝟙 (of { x // x ∈ AddMonoidHom.ker f })) x
[PROOFSTEP]
simp only [AddMonoidHom.coe_mk, coe_id, coe_comp]
[GOAL]
case w
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
⊢ ∀ (x : ↑(of { x // x ∈ AddMonoidHom.ker f })),
    (↑{ toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
              map_zero' :=
                (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) } ∘
          ↑(kernel.lift f (AddSubgroup.subtype (AddMonoidHom.ker f))
              (_ : AddSubgroup.subtype (AddMonoidHom.ker f) ≫ f = 0)))
        x =
      id x
[PROOFSTEP]
rintro ⟨x, mem⟩
[GOAL]
case w.mk
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
x : ↑G
mem : x ∈ AddMonoidHom.ker f
⊢ (↑{ toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
            map_zero' :=
              (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) } ∘
        ↑(kernel.lift f (AddSubgroup.subtype (AddMonoidHom.ker f))
            (_ : AddSubgroup.subtype (AddMonoidHom.ker f) ≫ f = 0)))
      { val := x, property := mem } =
    id { val := x, property := mem }
[PROOFSTEP]
refine Subtype.ext ?_
[GOAL]
case w.mk
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
x : ↑G
mem : x ∈ AddMonoidHom.ker f
⊢ ↑((↑{ toFun := fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) },
              map_zero' :=
                (_ : (fun g => { val := ↑(kernel.ι f) g, property := (_ : ↑(kernel.ι f ≫ f) g = ↑0 g) }) 0 = 0) } ∘
          ↑(kernel.lift f (AddSubgroup.subtype (AddMonoidHom.ker f))
              (_ : AddSubgroup.subtype (AddMonoidHom.ker f) ≫ f = 0)))
        { val := x, property := mem }) =
    ↑(id { val := x, property := mem })
[PROOFSTEP]
simp only [ZeroHom.coe_mk, Function.comp_apply, id_eq]
[GOAL]
case w.mk
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
x : ↑G
mem : x ∈ AddMonoidHom.ker f
⊢ ↑(kernel.ι f)
      (↑(kernel.lift f (AddSubgroup.subtype (AddMonoidHom.ker f))
            (_ : AddSubgroup.subtype (AddMonoidHom.ker f) ≫ f = 0))
        { val := x, property := mem }) =
    x
[PROOFSTEP]
generalize_proofs _ h1 h2
[GOAL]
case w.mk
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
x : ↑G
mem : x ∈ AddMonoidHom.ker f
h✝ : HasKernel f
h1 : AddSubgroup.subtype (AddMonoidHom.ker f) ≫ f = 0
⊢ ↑(kernel.ι f) (↑(kernel.lift f (AddSubgroup.subtype (AddMonoidHom.ker f)) h1) { val := x, property := mem }) = x
[PROOFSTEP]
erw [FunLike.congr_fun (kernel.lift_ι f _ h1) ⟨_, mem⟩]
[GOAL]
case w.mk
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
x : ↑G
mem : x ∈ AddMonoidHom.ker f
h✝ : HasKernel f
h1 : AddSubgroup.subtype (AddMonoidHom.ker f) ≫ f = 0
⊢ ↑(AddSubgroup.subtype (AddMonoidHom.ker f)) { val := x, property := mem } = x
[PROOFSTEP]
rfl
[GOAL]
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
⊢ (kernelIsoKer f).hom ≫ AddSubgroup.subtype (AddMonoidHom.ker f) = kernel.ι f
[PROOFSTEP]
ext
[GOAL]
case w
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
x✝ : ↑(kernel f)
⊢ ↑((kernelIsoKer f).hom ≫ AddSubgroup.subtype (AddMonoidHom.ker f)) x✝ = ↑(kernel.ι f) x✝
[PROOFSTEP]
rfl
[GOAL]
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
⊢ (kernelIsoKer f).inv ≫ kernel.ι f = AddSubgroup.subtype (AddMonoidHom.ker f)
[PROOFSTEP]
ext
[GOAL]
case w
J : Type v
inst✝ : SmallCategory J
G H : AddCommGroupCat
f : G ⟶ H
x✝ : ↑(of { x // x ∈ AddMonoidHom.ker f })
⊢ ↑((kernelIsoKer f).inv ≫ kernel.ι f) x✝ = ↑(AddSubgroup.subtype (AddMonoidHom.ker f)) x✝
[PROOFSTEP]
simp [kernelIsoKer]


[GOAL]
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
h : ∀ (c : Set α), IsChain r c → ∃ ub, ∀ (a : α), a ∈ c → r a ub
trans : ∀ {a b c : α}, r a b → r b c → r a c
this✝ : ∃ ub, ∀ (a : α), a ∈ maxChain r → r a ub
ub : α
hub : ∀ (a : α), a ∈ maxChain r → r a ub
a : α
ha : r ub a
this : IsChain r (insert a (maxChain r))
⊢ a ∈ maxChain r
[PROOFSTEP]
rw [maxChain_spec.right this (subset_insert _ _)]
[GOAL]
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
h : ∀ (c : Set α), IsChain r c → ∃ ub, ∀ (a : α), a ∈ c → r a ub
trans : ∀ {a b c : α}, r a b → r b c → r a c
this✝ : ∃ ub, ∀ (a : α), a ∈ maxChain r → r a ub
ub : α
hub : ∀ (a : α), a ∈ maxChain r → r a ub
a : α
ha : r ub a
this : IsChain r (insert a (maxChain r))
⊢ a ∈ insert a (maxChain r)
[PROOFSTEP]
exact mem_insert _ _
[GOAL]
α : Type u_1
β : Type u_2
r : α → α → Prop
c✝ : Set α
inst✝ : Preorder α
s : Set α
ih : ∀ (c : Set α), c ⊆ s → IsChain (fun x x_1 => x ≤ x_1) c → ∃ ub, ub ∈ s ∧ ∀ (z : α), z ∈ c → z ≤ ub
c : Set ↑s
hc : IsChain (fun x x_1 => x ≤ x_1) c
⊢ IsChain (fun x x_1 => x ≤ x_1) (Subtype.val '' c)
[PROOFSTEP]
rintro _ ⟨p, hpc, rfl⟩ _ ⟨q, hqc, rfl⟩ hpq
[GOAL]
case intro.intro.intro.intro
α : Type u_1
β : Type u_2
r : α → α → Prop
c✝ : Set α
inst✝ : Preorder α
s : Set α
ih : ∀ (c : Set α), c ⊆ s → IsChain (fun x x_1 => x ≤ x_1) c → ∃ ub, ub ∈ s ∧ ∀ (z : α), z ∈ c → z ≤ ub
c : Set ↑s
hc : IsChain (fun x x_1 => x ≤ x_1) c
p : { x // x ∈ s }
hpc : p ∈ c
q : { x // x ∈ s }
hqc : q ∈ c
hpq : ↑p ≠ ↑q
⊢ (fun x x_1 => x ≤ x_1) ↑p ↑q ∨ (fun x x_1 => x ≤ x_1) ↑q ↑p
[PROOFSTEP]
refine' hc hpc hqc fun t => hpq (Subtype.ext_iff.1 t)
[GOAL]
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
inst✝ : Preorder α
s : Set α
ih :
  ∀ (c : Set α), c ⊆ s → IsChain (fun x x_1 => x ≤ x_1) c → ∀ (y : α), y ∈ c → ∃ ub, ub ∈ s ∧ ∀ (z : α), z ∈ c → z ≤ ub
x : α
hxs : x ∈ s
⊢ ∃ m, m ∈ s ∧ x ≤ m ∧ ∀ (z : α), z ∈ s → m ≤ z → z ≤ m
[PROOFSTEP]
have H := zorn_preorder₀ ({y ∈ s | x ≤ y}) fun c hcs hc => ?_
[GOAL]
case refine_2
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
inst✝ : Preorder α
s : Set α
ih :
  ∀ (c : Set α), c ⊆ s → IsChain (fun x x_1 => x ≤ x_1) c → ∀ (y : α), y ∈ c → ∃ ub, ub ∈ s ∧ ∀ (z : α), z ∈ c → z ≤ ub
x : α
hxs : x ∈ s
H : ∃ m, m ∈ {y | y ∈ s ∧ x ≤ y} ∧ ∀ (z : α), z ∈ {y | y ∈ s ∧ x ≤ y} → m ≤ z → z ≤ m
⊢ ∃ m, m ∈ s ∧ x ≤ m ∧ ∀ (z : α), z ∈ s → m ≤ z → z ≤ m
[PROOFSTEP]
rcases H with ⟨m, ⟨hms, hxm⟩, hm⟩
[GOAL]
case refine_2.intro.intro.intro
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
inst✝ : Preorder α
s : Set α
ih :
  ∀ (c : Set α), c ⊆ s → IsChain (fun x x_1 => x ≤ x_1) c → ∀ (y : α), y ∈ c → ∃ ub, ub ∈ s ∧ ∀ (z : α), z ∈ c → z ≤ ub
x : α
hxs : x ∈ s
m : α
hm : ∀ (z : α), z ∈ {y | y ∈ s ∧ x ≤ y} → m ≤ z → z ≤ m
hms : m ∈ s
hxm : x ≤ m
⊢ ∃ m, m ∈ s ∧ x ≤ m ∧ ∀ (z : α), z ∈ s → m ≤ z → z ≤ m
[PROOFSTEP]
exact ⟨m, hms, hxm, fun z hzs hmz => hm _ ⟨hzs, hxm.trans hmz⟩ hmz⟩
[GOAL]
case refine_1
α : Type u_1
β : Type u_2
r : α → α → Prop
c✝ : Set α
inst✝ : Preorder α
s : Set α
ih :
  ∀ (c : Set α), c ⊆ s → IsChain (fun x x_1 => x ≤ x_1) c → ∀ (y : α), y ∈ c → ∃ ub, ub ∈ s ∧ ∀ (z : α), z ∈ c → z ≤ ub
x : α
hxs : x ∈ s
c : Set α
hcs : c ⊆ {y | y ∈ s ∧ x ≤ y}
hc : IsChain (fun x x_1 => x ≤ x_1) c
⊢ ∃ ub, ub ∈ {y | y ∈ s ∧ x ≤ y} ∧ ∀ (z : α), z ∈ c → z ≤ ub
[PROOFSTEP]
rcases c.eq_empty_or_nonempty with (rfl | ⟨y, hy⟩)
[GOAL]
case refine_1.inl
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
inst✝ : Preorder α
s : Set α
ih :
  ∀ (c : Set α), c ⊆ s → IsChain (fun x x_1 => x ≤ x_1) c → ∀ (y : α), y ∈ c → ∃ ub, ub ∈ s ∧ ∀ (z : α), z ∈ c → z ≤ ub
x : α
hxs : x ∈ s
hcs : ∅ ⊆ {y | y ∈ s ∧ x ≤ y}
hc : IsChain (fun x x_1 => x ≤ x_1) ∅
⊢ ∃ ub, ub ∈ {y | y ∈ s ∧ x ≤ y} ∧ ∀ (z : α), z ∈ ∅ → z ≤ ub
[PROOFSTEP]
exact ⟨x, ⟨hxs, le_rfl⟩, fun z => False.elim⟩
[GOAL]
case refine_1.inr.intro
α : Type u_1
β : Type u_2
r : α → α → Prop
c✝ : Set α
inst✝ : Preorder α
s : Set α
ih :
  ∀ (c : Set α), c ⊆ s → IsChain (fun x x_1 => x ≤ x_1) c → ∀ (y : α), y ∈ c → ∃ ub, ub ∈ s ∧ ∀ (z : α), z ∈ c → z ≤ ub
x : α
hxs : x ∈ s
c : Set α
hcs : c ⊆ {y | y ∈ s ∧ x ≤ y}
hc : IsChain (fun x x_1 => x ≤ x_1) c
y : α
hy : y ∈ c
⊢ ∃ ub, ub ∈ {y | y ∈ s ∧ x ≤ y} ∧ ∀ (z : α), z ∈ c → z ≤ ub
[PROOFSTEP]
rcases ih c (fun z hz => (hcs hz).1) hc y hy with ⟨z, hzs, hz⟩
[GOAL]
case refine_1.inr.intro.intro.intro
α : Type u_1
β : Type u_2
r : α → α → Prop
c✝ : Set α
inst✝ : Preorder α
s : Set α
ih :
  ∀ (c : Set α), c ⊆ s → IsChain (fun x x_1 => x ≤ x_1) c → ∀ (y : α), y ∈ c → ∃ ub, ub ∈ s ∧ ∀ (z : α), z ∈ c → z ≤ ub
x : α
hxs : x ∈ s
c : Set α
hcs : c ⊆ {y | y ∈ s ∧ x ≤ y}
hc : IsChain (fun x x_1 => x ≤ x_1) c
y : α
hy : y ∈ c
z : α
hzs : z ∈ s
hz : ∀ (z_1 : α), z_1 ∈ c → z_1 ≤ z
⊢ ∃ ub, ub ∈ {y | y ∈ s ∧ x ≤ y} ∧ ∀ (z : α), z ∈ c → z ≤ ub
[PROOFSTEP]
exact ⟨z, ⟨hzs, (hcs hy).2.trans <| hz _ hy⟩, hz⟩
[GOAL]
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
inst✝ : Preorder α
a : α
ih :
  ∀ (c : Set α),
    c ⊆ Ici a → IsChain (fun x x_1 => x ≤ x_1) c → ∀ (y : α), y ∈ c → ∃ ub, a ≤ ub ∧ ∀ (z : α), z ∈ c → z ≤ ub
x : α
hax : a ≤ x
⊢ ∀ (c : Set α),
    c ⊆ Ici a → IsChain (fun x x_1 => x ≤ x_1) c → ∀ (y : α), y ∈ c → ∃ ub, ub ∈ Ici a ∧ ∀ (z : α), z ∈ c → z ≤ ub
[PROOFSTEP]
simpa using ih
[GOAL]
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
hc : IsChain r c
⊢ ∃ M, IsMaxChain r M ∧ c ⊆ M
[PROOFSTEP]
have H := zorn_subset_nonempty {s | c ⊆ s ∧ IsChain r s} ?_ c ⟨Subset.rfl, hc⟩
[GOAL]
case refine_2
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
hc : IsChain r c
H : ∃ m, m ∈ {s | c ⊆ s ∧ IsChain r s} ∧ c ⊆ m ∧ ∀ (a : Set α), a ∈ {s | c ⊆ s ∧ IsChain r s} → m ⊆ a → a = m
⊢ ∃ M, IsMaxChain r M ∧ c ⊆ M
[PROOFSTEP]
obtain ⟨M, ⟨_, hM₀⟩, hM₁, hM₂⟩ := H
[GOAL]
case refine_2.intro.intro.intro.intro
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
hc : IsChain r c
M : Set α
left✝ : c ⊆ M
hM₀ : IsChain r M
hM₁ : c ⊆ M
hM₂ : ∀ (a : Set α), a ∈ {s | c ⊆ s ∧ IsChain r s} → M ⊆ a → a = M
⊢ ∃ M, IsMaxChain r M ∧ c ⊆ M
[PROOFSTEP]
exact ⟨M, ⟨hM₀, fun d hd hMd => (hM₂ _ ⟨hM₁.trans hMd, hd⟩ hMd).symm⟩, hM₁⟩
[GOAL]
case refine_1
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
hc : IsChain r c
⊢ ∀ (c_1 : Set (Set α)),
    c_1 ⊆ {s | c ⊆ s ∧ IsChain r s} →
      IsChain (fun x x_1 => x ⊆ x_1) c_1 →
        Set.Nonempty c_1 → ∃ ub, ub ∈ {s | c ⊆ s ∧ IsChain r s} ∧ ∀ (s : Set α), s ∈ c_1 → s ⊆ ub
[PROOFSTEP]
rintro cs hcs₀ hcs₁ ⟨s, hs⟩
[GOAL]
case refine_1.intro
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
hc : IsChain r c
cs : Set (Set α)
hcs₀ : cs ⊆ {s | c ⊆ s ∧ IsChain r s}
hcs₁ : IsChain (fun x x_1 => x ⊆ x_1) cs
s : Set α
hs : s ∈ cs
⊢ ∃ ub, ub ∈ {s | c ⊆ s ∧ IsChain r s} ∧ ∀ (s : Set α), s ∈ cs → s ⊆ ub
[PROOFSTEP]
refine' ⟨⋃₀ cs, ⟨fun _ ha => Set.mem_sUnion_of_mem ((hcs₀ hs).left ha) hs, _⟩, fun _ => Set.subset_sUnion_of_mem⟩
[GOAL]
case refine_1.intro
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
hc : IsChain r c
cs : Set (Set α)
hcs₀ : cs ⊆ {s | c ⊆ s ∧ IsChain r s}
hcs₁ : IsChain (fun x x_1 => x ⊆ x_1) cs
s : Set α
hs : s ∈ cs
⊢ IsChain r (⋃₀ cs)
[PROOFSTEP]
rintro y ⟨sy, hsy, hysy⟩ z ⟨sz, hsz, hzsz⟩ hyz
[GOAL]
case refine_1.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
hc : IsChain r c
cs : Set (Set α)
hcs₀ : cs ⊆ {s | c ⊆ s ∧ IsChain r s}
hcs₁ : IsChain (fun x x_1 => x ⊆ x_1) cs
s : Set α
hs : s ∈ cs
y : α
sy : Set α
hsy : sy ∈ cs
hysy : y ∈ sy
z : α
sz : Set α
hsz : sz ∈ cs
hzsz : z ∈ sz
hyz : y ≠ z
⊢ r y z ∨ r z y
[PROOFSTEP]
obtain rfl | hsseq := eq_or_ne sy sz
[GOAL]
case refine_1.intro.intro.intro.intro.intro.inl
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
hc : IsChain r c
cs : Set (Set α)
hcs₀ : cs ⊆ {s | c ⊆ s ∧ IsChain r s}
hcs₁ : IsChain (fun x x_1 => x ⊆ x_1) cs
s : Set α
hs : s ∈ cs
y : α
sy : Set α
hsy : sy ∈ cs
hysy : y ∈ sy
z : α
hyz : y ≠ z
hsz : sy ∈ cs
hzsz : z ∈ sy
⊢ r y z ∨ r z y
[PROOFSTEP]
exact (hcs₀ hsy).right hysy hzsz hyz
[GOAL]
case refine_1.intro.intro.intro.intro.intro.inr
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
hc : IsChain r c
cs : Set (Set α)
hcs₀ : cs ⊆ {s | c ⊆ s ∧ IsChain r s}
hcs₁ : IsChain (fun x x_1 => x ⊆ x_1) cs
s : Set α
hs : s ∈ cs
y : α
sy : Set α
hsy : sy ∈ cs
hysy : y ∈ sy
z : α
sz : Set α
hsz : sz ∈ cs
hzsz : z ∈ sz
hyz : y ≠ z
hsseq : sy ≠ sz
⊢ r y z ∨ r z y
[PROOFSTEP]
cases' hcs₁ hsy hsz hsseq with h h
[GOAL]
case refine_1.intro.intro.intro.intro.intro.inr.inl
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
hc : IsChain r c
cs : Set (Set α)
hcs₀ : cs ⊆ {s | c ⊆ s ∧ IsChain r s}
hcs₁ : IsChain (fun x x_1 => x ⊆ x_1) cs
s : Set α
hs : s ∈ cs
y : α
sy : Set α
hsy : sy ∈ cs
hysy : y ∈ sy
z : α
sz : Set α
hsz : sz ∈ cs
hzsz : z ∈ sz
hyz : y ≠ z
hsseq : sy ≠ sz
h : (fun x x_1 => x ⊆ x_1) sy sz
⊢ r y z ∨ r z y
[PROOFSTEP]
exact (hcs₀ hsz).right (h hysy) hzsz hyz
[GOAL]
case refine_1.intro.intro.intro.intro.intro.inr.inr
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
hc : IsChain r c
cs : Set (Set α)
hcs₀ : cs ⊆ {s | c ⊆ s ∧ IsChain r s}
hcs₁ : IsChain (fun x x_1 => x ⊆ x_1) cs
s : Set α
hs : s ∈ cs
y : α
sy : Set α
hsy : sy ∈ cs
hysy : y ∈ sy
z : α
sz : Set α
hsz : sz ∈ cs
hzsz : z ∈ sz
hyz : y ≠ z
hsseq : sy ≠ sz
h : (fun x x_1 => x ⊆ x_1) sz sy
⊢ r y z ∨ r z y
[PROOFSTEP]
exact (hcs₀ hsy).right hysy (h hzsz) hyz


[GOAL]
A : Type u_1
inst✝¹ : Mul A
inst✝ : IsCommJordan A
a b : A
⊢ a * b * a = a * (b * a)
[PROOFSTEP]
rw [IsCommJordan.mul_comm, IsCommJordan.mul_comm a b]
[GOAL]
A : Type u_1
inst✝¹ : Mul A
inst✝ : IsCommJordan A
a b : A
⊢ a * a * (a * b) = a * (a * a * b)
[PROOFSTEP]
rw [IsCommJordan.mul_comm (a * a) (a * b), IsCommJordan.lmul_comm_rmul_rmul, IsCommJordan.mul_comm b (a * a)]
[GOAL]
A : Type u_1
inst✝¹ : Mul A
inst✝ : IsCommJordan A
a b : A
⊢ a * a * (b * a) = a * a * b * a
[PROOFSTEP]
rw [IsCommJordan.mul_comm (a * a) (b * a), IsCommJordan.mul_comm b a, IsCommJordan.lmul_comm_rmul_rmul,
  IsCommJordan.mul_comm, IsCommJordan.mul_comm b (a * a)]
[GOAL]
A : Type u_1
inst✝¹ : Mul A
inst✝ : IsCommJordan A
a b : A
⊢ b * a * (a * a) = b * (a * a) * a
[PROOFSTEP]
rw [IsCommJordan.mul_comm b a, IsCommJordan.lmul_comm_rmul_rmul, IsCommJordan.mul_comm]
[GOAL]
A : Type u_1
inst✝ : Semigroup A
a b : A
⊢ a * b * a = a * (b * a)
[PROOFSTEP]
rw [mul_assoc]
[GOAL]
A : Type u_1
inst✝ : Semigroup A
a b : A
⊢ a * a * (a * b) = a * (a * a * b)
[PROOFSTEP]
rw [mul_assoc, mul_assoc]
[GOAL]
A : Type u_1
inst✝ : Semigroup A
a b : A
⊢ a * a * (b * a) = a * a * b * a
[PROOFSTEP]
rw [← mul_assoc]
[GOAL]
A : Type u_1
inst✝ : Semigroup A
a b : A
⊢ a * b * (a * a) = a * (b * (a * a))
[PROOFSTEP]
rw [mul_assoc]
[GOAL]
A : Type u_1
inst✝ : Semigroup A
a b : A
⊢ b * a * (a * a) = b * (a * a) * a
[PROOFSTEP]
rw [← mul_assoc, ← mul_assoc]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b : A
⊢ 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (b * a)⁆) = ⁅↑L (a * a), ↑L b⁆ + ⁅↑L (b * b), ↑L a⁆
[PROOFSTEP]
suffices 2 • ⁅L a, L (a * b)⁆ + 2 • ⁅L b, L (b * a)⁆ + ⁅L b, L (a * a)⁆ + ⁅L a, L (b * b)⁆ = 0 by
  rwa [← sub_eq_zero, ← sub_sub, sub_eq_add_neg, sub_eq_add_neg, lie_skew, lie_skew, nsmul_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b : A
this : 2 • ⁅↑L a, ↑L (a * b)⁆ + 2 • ⁅↑L b, ↑L (b * a)⁆ + ⁅↑L b, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ = 0
⊢ 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (b * a)⁆) = ⁅↑L (a * a), ↑L b⁆ + ⁅↑L (b * b), ↑L a⁆
[PROOFSTEP]
rwa [← sub_eq_zero, ← sub_sub, sub_eq_add_neg, sub_eq_add_neg, lie_skew, lie_skew, nsmul_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b : A
⊢ 2 • ⁅↑L a, ↑L (a * b)⁆ + 2 • ⁅↑L b, ↑L (b * a)⁆ + ⁅↑L b, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ = 0
[PROOFSTEP]
convert (commute_lmul_lmul_sq (a + b)).lie_eq using 1
[GOAL]
case h.e'_2
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b : A
⊢ 2 • ⁅↑L a, ↑L (a * b)⁆ + 2 • ⁅↑L b, ↑L (b * a)⁆ + ⁅↑L b, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ =
    ⁅↑L (a + b), ↑L ((a + b) * (a + b))⁆
[PROOFSTEP]
simp only [add_mul, mul_add, map_add, lie_add, add_lie, IsCommJordan.mul_comm b a, (commute_lmul_lmul_sq a).lie_eq,
  (commute_lmul_lmul_sq b).lie_eq, zero_add, add_zero, two_smul]
[GOAL]
case h.e'_2
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b : A
⊢ ⁅↑L a, ↑L (a * b)⁆ + ⁅↑L a, ↑L (a * b)⁆ + (⁅↑L b, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆) + ⁅↑L b, ↑L (a * a)⁆ +
      ⁅↑L a, ↑L (b * b)⁆ =
    ⁅↑L b, ↑L (a * a)⁆ + (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆) +
      (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆ + ⁅↑L a, ↑L (b * b)⁆)
[PROOFSTEP]
abel
[GOAL]
case h.e'_2
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b : A
⊢ ⁅↑L a, ↑L (a * b)⁆ + ⁅↑L a, ↑L (a * b)⁆ + (⁅↑L b, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆) + ⁅↑L b, ↑L (a * a)⁆ +
      ⁅↑L a, ↑L (b * b)⁆ =
    ⁅↑L b, ↑L (a * a)⁆ + (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆) +
      (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆ + ⁅↑L a, ↑L (b * b)⁆)
[PROOFSTEP]
abel
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L (a + b + c), ↑L ((a + b + c) * (a + b + c))⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [add_mul, add_mul]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L (a + b + c), ↑L (a * (a + b + c) + b * (a + b + c) + c * (a + b + c))⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
iterate 6 rw [mul_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L (a + b + c), ↑L (a * (a + b + c) + b * (a + b + c) + c * (a + b + c))⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [mul_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L (a + b + c), ↑L (a * (a + b) + a * c + b * (a + b + c) + c * (a + b + c))⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [mul_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L (a + b + c), ↑L (a * a + a * b + a * c + b * (a + b + c) + c * (a + b + c))⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [mul_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L (a + b + c), ↑L (a * a + a * b + a * c + (b * (a + b) + b * c) + c * (a + b + c))⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [mul_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L (a + b + c), ↑L (a * a + a * b + a * c + (b * a + b * b + b * c) + c * (a + b + c))⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [mul_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L (a + b + c), ↑L (a * a + a * b + a * c + (b * a + b * b + b * c) + (c * (a + b) + c * c))⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [mul_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L (a + b + c), ↑L (a * a + a * b + a * c + (b * a + b * b + b * c) + (c * a + c * b + c * c))⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
iterate 10 rw [map_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L (a + b + c), ↑L (a * a + a * b + a * c + (b * a + b * b + b * c) + (c * a + c * b + c * c))⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [map_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L (a + b) + ↑L c, ↑L (a * a + a * b + a * c + (b * a + b * b + b * c) + (c * a + c * b + c * c))⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [map_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a + ↑L b + ↑L c, ↑L (a * a + a * b + a * c + (b * a + b * b + b * c) + (c * a + c * b + c * c))⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [map_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a + ↑L b + ↑L c, ↑L (a * a + a * b + a * c + (b * a + b * b + b * c)) + ↑L (c * a + c * b + c * c)⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [map_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a + ↑L b + ↑L c, ↑L (a * a + a * b + a * c) + ↑L (b * a + b * b + b * c) + ↑L (c * a + c * b + c * c)⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [map_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a + ↑L b + ↑L c, ↑L (a * a + a * b) + ↑L (a * c) + ↑L (b * a + b * b + b * c) + ↑L (c * a + c * b + c * c)⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [map_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (a * b) + ↑L (a * c) + ↑L (b * a + b * b + b * c) + ↑L (c * a + c * b + c * c)⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [map_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a + ↑L b + ↑L c,
      ↑L (a * a) + ↑L (a * b) + ↑L (a * c) + (↑L (b * a + b * b) + ↑L (b * c)) + ↑L (c * a + c * b + c * c)⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [map_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a + ↑L b + ↑L c,
      ↑L (a * a) + ↑L (a * b) + ↑L (a * c) + (↑L (b * a) + ↑L (b * b) + ↑L (b * c)) + ↑L (c * a + c * b + c * c)⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [map_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a + ↑L b + ↑L c,
      ↑L (a * a) + ↑L (a * b) + ↑L (a * c) + (↑L (b * a) + ↑L (b * b) + ↑L (b * c)) +
        (↑L (c * a + c * b) + ↑L (c * c))⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [map_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a + ↑L b + ↑L c,
      ↑L (a * a) + ↑L (a * b) + ↑L (a * c) + (↑L (b * a) + ↑L (b * b) + ↑L (b * c)) +
        (↑L (c * a) + ↑L (c * b) + ↑L (c * c))⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [IsCommJordan.mul_comm b a, IsCommJordan.mul_comm c a, IsCommJordan.mul_comm c b]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a + ↑L b + ↑L c,
      ↑L (a * a) + ↑L (a * b) + ↑L (a * c) + (↑L (a * b) + ↑L (b * b) + ↑L (b * c)) +
        (↑L (a * c) + ↑L (b * c) + ↑L (c * c))⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (a * c) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
iterate 3 rw [two_smul]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a + ↑L b + ↑L c,
      ↑L (a * a) + ↑L (a * b) + ↑L (a * c) + (↑L (a * b) + ↑L (b * b) + ↑L (b * c)) +
        (↑L (a * c) + ↑L (b * c) + ↑L (c * c))⁆ =
    ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (a * c) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [two_smul]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a + ↑L b + ↑L c,
      ↑L (a * a) + ↑L (a * b) + ↑L (a * c) + (↑L (a * b) + ↑L (b * b) + ↑L (b * c)) +
        (↑L (a * c) + ↑L (b * c) + ↑L (c * c))⁆ =
    ⁅↑L a + ↑L b + ↑L c,
      ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + (↑L (a * b) + ↑L (a * b)) + 2 • ↑L (a * c) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [two_smul]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a + ↑L b + ↑L c,
      ↑L (a * a) + ↑L (a * b) + ↑L (a * c) + (↑L (a * b) + ↑L (b * b) + ↑L (b * c)) +
        (↑L (a * c) + ↑L (b * c) + ↑L (c * c))⁆ =
    ⁅↑L a + ↑L b + ↑L c,
      ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + (↑L (a * b) + ↑L (a * b)) + (↑L (a * c) + ↑L (a * c)) + 2 • ↑L (b * c)⁆
[PROOFSTEP]
rw [two_smul]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a + ↑L b + ↑L c,
      ↑L (a * a) + ↑L (a * b) + ↑L (a * c) + (↑L (a * b) + ↑L (b * b) + ↑L (b * c)) +
        (↑L (a * c) + ↑L (b * c) + ↑L (c * c))⁆ =
    ⁅↑L a + ↑L b + ↑L c,
      ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + (↑L (a * b) + ↑L (a * b)) + (↑L (a * c) + ↑L (a * c)) +
        (↑L (b * c) + ↑L (b * c))⁆
[PROOFSTEP]
simp only [lie_add, add_lie, commute_lmul_lmul_sq, zero_add, add_zero]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L b, ↑L (a * a)⁆ + ⁅↑L c, ↑L (a * a)⁆ +
            (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆ + ⁅↑L c, ↑L (a * b)⁆) +
          (⁅↑L a, ↑L (a * c)⁆ + ⁅↑L b, ↑L (a * c)⁆ + ⁅↑L c, ↑L (a * c)⁆) +
        (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆ + ⁅↑L c, ↑L (a * b)⁆ +
            (⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L c, ↑L (b * b)⁆) +
          (⁅↑L a, ↑L (b * c)⁆ + ⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆)) +
      (⁅↑L a, ↑L (a * c)⁆ + ⁅↑L b, ↑L (a * c)⁆ + ⁅↑L c, ↑L (a * c)⁆ +
          (⁅↑L a, ↑L (b * c)⁆ + ⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆) +
        (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (c * c)⁆)) =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L b, ↑L (a * a)⁆ + ⁅↑L c, ↑L (a * a)⁆ +
              (⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L c, ↑L (b * b)⁆) +
            (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (c * c)⁆) +
          (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆ + ⁅↑L c, ↑L (a * b)⁆ +
            (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆ + ⁅↑L c, ↑L (a * b)⁆)) +
        (⁅↑L a, ↑L (a * c)⁆ + ⁅↑L b, ↑L (a * c)⁆ + ⁅↑L c, ↑L (a * c)⁆ +
          (⁅↑L a, ↑L (a * c)⁆ + ⁅↑L b, ↑L (a * c)⁆ + ⁅↑L c, ↑L (a * c)⁆)) +
      (⁅↑L a, ↑L (b * c)⁆ + ⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆ +
        (⁅↑L a, ↑L (b * c)⁆ + ⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆))
[PROOFSTEP]
abel
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L b, ↑L (a * a)⁆ + ⁅↑L c, ↑L (a * a)⁆ +
            (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆ + ⁅↑L c, ↑L (a * b)⁆) +
          (⁅↑L a, ↑L (a * c)⁆ + ⁅↑L b, ↑L (a * c)⁆ + ⁅↑L c, ↑L (a * c)⁆) +
        (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆ + ⁅↑L c, ↑L (a * b)⁆ +
            (⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L c, ↑L (b * b)⁆) +
          (⁅↑L a, ↑L (b * c)⁆ + ⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆)) +
      (⁅↑L a, ↑L (a * c)⁆ + ⁅↑L b, ↑L (a * c)⁆ + ⁅↑L c, ↑L (a * c)⁆ +
          (⁅↑L a, ↑L (b * c)⁆ + ⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆) +
        (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (c * c)⁆)) =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L b, ↑L (a * a)⁆ + ⁅↑L c, ↑L (a * a)⁆ +
              (⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L c, ↑L (b * b)⁆) +
            (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (c * c)⁆) +
          (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆ + ⁅↑L c, ↑L (a * b)⁆ +
            (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆ + ⁅↑L c, ↑L (a * b)⁆)) +
        (⁅↑L a, ↑L (a * c)⁆ + ⁅↑L b, ↑L (a * c)⁆ + ⁅↑L c, ↑L (a * c)⁆ +
          (⁅↑L a, ↑L (a * c)⁆ + ⁅↑L b, ↑L (a * c)⁆ + ⁅↑L c, ↑L (a * c)⁆)) +
      (⁅↑L a, ↑L (b * c)⁆ + ⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆ +
        (⁅↑L a, ↑L (b * c)⁆ + ⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆))
[PROOFSTEP]
abel
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
[PROOFSTEP]
rw [add_lie, add_lie]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ +
        ⁅↑L b, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ +
      ⁅↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
[PROOFSTEP]
iterate 15 rw [lie_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ +
        ⁅↑L b, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ +
      ⁅↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
[PROOFSTEP]
rw [lie_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a)⁆ + ⁅↑L a, 2 • ↑L (b * c)⁆ +
        ⁅↑L b, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ +
      ⁅↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
[PROOFSTEP]
rw [lie_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ + ⁅↑L a, 2 • ↑L (b * c)⁆ +
        ⁅↑L b, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ +
      ⁅↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
[PROOFSTEP]
rw [lie_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a) + ↑L (b * b) + ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        ⁅↑L b, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ +
      ⁅↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
[PROOFSTEP]
rw [lie_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a) + ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        ⁅↑L b, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ +
      ⁅↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
[PROOFSTEP]
rw [lie_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        ⁅↑L b, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ +
      ⁅↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
[PROOFSTEP]
rw [lie_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a)⁆ + ⁅↑L b, 2 • ↑L (b * c)⁆) +
      ⁅↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
[PROOFSTEP]
rw [lie_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b)⁆ + ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      ⁅↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
[PROOFSTEP]
rw [lie_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a) + ↑L (b * b) + ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ + ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      ⁅↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
[PROOFSTEP]
rw [lie_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a) + ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ + ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      ⁅↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
[PROOFSTEP]
rw [lie_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      ⁅↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
[PROOFSTEP]
rw [lie_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a)⁆ + ⁅↑L c, 2 • ↑L (b * c)⁆) =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
[PROOFSTEP]
rw [lie_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆) =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
[PROOFSTEP]
rw [lie_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆) =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
[PROOFSTEP]
rw [lie_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a) + ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆) =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
[PROOFSTEP]
rw [lie_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆) =
    ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆) +
          (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (c * a)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
        (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆)) +
      (2 • ⁅↑L a, ↑L (b * c)⁆ + 2 • ⁅↑L b, ↑L (c * a)⁆ + 2 • ⁅↑L c, ↑L (a * b)⁆)
[PROOFSTEP]
rw [(commute_lmul_lmul_sq a).lie_eq, (commute_lmul_lmul_sq b).lie_eq, (commute_lmul_lmul_sq c).lie_eq, zero_add,
  add_zero, add_zero]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ + ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ + ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆) =
    ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆) +
          (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (c * a)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
        (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆)) +
      (2 • ⁅↑L a, ↑L (b * c)⁆ + 2 • ⁅↑L b, ↑L (c * a)⁆ + 2 • ⁅↑L c, ↑L (a * b)⁆)
[PROOFSTEP]
simp only [lie_nsmul]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + 2 • ⁅↑L a, ↑L (a * b)⁆ + 2 • ⁅↑L a, ↑L (c * a)⁆ + 2 • ⁅↑L a, ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (c * c)⁆ + 2 • ⁅↑L b, ↑L (a * b)⁆ + 2 • ⁅↑L b, ↑L (c * a)⁆ +
          2 • ⁅↑L b, ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • ⁅↑L c, ↑L (a * b)⁆ + 2 • ⁅↑L c, ↑L (c * a)⁆ +
        2 • ⁅↑L c, ↑L (b * c)⁆) =
    ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆) +
          (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (c * a)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
        (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆)) +
      (2 • ⁅↑L a, ↑L (b * c)⁆ + 2 • ⁅↑L b, ↑L (c * a)⁆ + 2 • ⁅↑L c, ↑L (a * b)⁆)
[PROOFSTEP]
abel
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + 2 • ⁅↑L a, ↑L (a * b)⁆ + 2 • ⁅↑L a, ↑L (c * a)⁆ + 2 • ⁅↑L a, ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (c * c)⁆ + 2 • ⁅↑L b, ↑L (a * b)⁆ + 2 • ⁅↑L b, ↑L (c * a)⁆ +
          2 • ⁅↑L b, ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • ⁅↑L c, ↑L (a * b)⁆ + 2 • ⁅↑L c, ↑L (c * a)⁆ +
        2 • ⁅↑L c, ↑L (b * c)⁆) =
    ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆) +
          (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (c * a)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
        (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆)) +
      (2 • ⁅↑L a, ↑L (b * c)⁆ + 2 • ⁅↑L b, ↑L (c * a)⁆ + 2 • ⁅↑L c, ↑L (a * b)⁆)
[PROOFSTEP]
abel
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆) +
          (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (c * a)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
        (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆)) +
      (2 • ⁅↑L a, ↑L (b * c)⁆ + 2 • ⁅↑L b, ↑L (c * a)⁆ + 2 • ⁅↑L c, ↑L (a * b)⁆) =
    2 • ⁅↑L a, ↑L (b * c)⁆ + 2 • ⁅↑L b, ↑L (c * a)⁆ + 2 • ⁅↑L c, ↑L (a * b)⁆
[PROOFSTEP]
rw [add_left_eq_self]
  -- Porting note: was `nth_rw` instead of `conv_lhs`
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆) +
        (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (c * a)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
      (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆)) =
    0
[PROOFSTEP]
conv_lhs => enter [1, 1, 2, 2, 2]; rw [IsCommJordan.mul_comm a b]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
| ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆) +
      (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (c * a)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
    (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆))
[PROOFSTEP]
enter [1, 1, 2, 2, 2]; rw [IsCommJordan.mul_comm a b]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
| ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆) +
      (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (c * a)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
    (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆))
[PROOFSTEP]
enter [1, 1, 2, 2, 2]; rw [IsCommJordan.mul_comm a b]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
| ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆) +
      (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (c * a)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
    (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆))
[PROOFSTEP]
enter [1, 1, 2, 2, 2]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
| ⁅↑L b, ↑L (a * b)⁆
[PROOFSTEP]
rw [IsCommJordan.mul_comm a b]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (b * a)⁆) +
        (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (c * a)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
      (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆)) =
    0
[PROOFSTEP]
conv_lhs => enter [1, 2, 2, 2, 1]; rw [IsCommJordan.mul_comm c a]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
| ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (b * a)⁆) +
      (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (c * a)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
    (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆))
[PROOFSTEP]
enter [1, 2, 2, 2, 1]; rw [IsCommJordan.mul_comm c a]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
| ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (b * a)⁆) +
      (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (c * a)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
    (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆))
[PROOFSTEP]
enter [1, 2, 2, 2, 1]; rw [IsCommJordan.mul_comm c a]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
| ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (b * a)⁆) +
      (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (c * a)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
    (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆))
[PROOFSTEP]
enter [1, 2, 2, 2, 1]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
| ⁅↑L a, ↑L (c * a)⁆
[PROOFSTEP]
rw [IsCommJordan.mul_comm c a]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (b * a)⁆) +
        (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * c)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
      (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆)) =
    0
[PROOFSTEP]
conv_lhs => enter [2, 2, 2, 2]; rw [IsCommJordan.mul_comm b c]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
| ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (b * a)⁆) +
      (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * c)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
    (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆))
[PROOFSTEP]
enter [2, 2, 2, 2]; rw [IsCommJordan.mul_comm b c]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
| ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (b * a)⁆) +
      (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * c)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
    (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆))
[PROOFSTEP]
enter [2, 2, 2, 2]; rw [IsCommJordan.mul_comm b c]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
| ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (b * a)⁆) +
      (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * c)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
    (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆))
[PROOFSTEP]
enter [2, 2, 2, 2]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
| ⁅↑L c, ↑L (b * c)⁆
[PROOFSTEP]
rw [IsCommJordan.mul_comm b c]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (b * a)⁆) +
        (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * c)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
      (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (c * b)⁆)) =
    0
[PROOFSTEP]
iterate 3 rw [two_nsmul_lie_lmul_lmul_add_eq_lie_lmul_lmul_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (b * a)⁆) +
        (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * c)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
      (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (c * b)⁆)) =
    0
[PROOFSTEP]
rw [two_nsmul_lie_lmul_lmul_add_eq_lie_lmul_lmul_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + (⁅↑L (a * a), ↑L b⁆ + ⁅↑L (b * b), ↑L a⁆) +
        (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * c)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
      (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (c * b)⁆)) =
    0
[PROOFSTEP]
rw [two_nsmul_lie_lmul_lmul_add_eq_lie_lmul_lmul_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + (⁅↑L (a * a), ↑L b⁆ + ⁅↑L (b * b), ↑L a⁆) +
        (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + (⁅↑L (a * a), ↑L c⁆ + ⁅↑L (c * c), ↑L a⁆)) +
      (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (c * b)⁆)) =
    0
[PROOFSTEP]
rw [two_nsmul_lie_lmul_lmul_add_eq_lie_lmul_lmul_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + (⁅↑L (a * a), ↑L b⁆ + ⁅↑L (b * b), ↑L a⁆) +
        (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + (⁅↑L (a * a), ↑L c⁆ + ⁅↑L (c * c), ↑L a⁆)) +
      (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + (⁅↑L (b * b), ↑L c⁆ + ⁅↑L (c * c), ↑L b⁆)) =
    0
[PROOFSTEP]
iterate 2 rw [← lie_skew (L (a * a)), ← lie_skew (L (b * b)), ← lie_skew (L (c * c))]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + (⁅↑L (a * a), ↑L b⁆ + ⁅↑L (b * b), ↑L a⁆) +
        (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + (⁅↑L (a * a), ↑L c⁆ + ⁅↑L (c * c), ↑L a⁆)) +
      (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + (⁅↑L (b * b), ↑L c⁆ + ⁅↑L (c * c), ↑L b⁆)) =
    0
[PROOFSTEP]
rw [← lie_skew (L (a * a)), ← lie_skew (L (b * b)), ← lie_skew (L (c * c))]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + (-⁅↑L b, ↑L (a * a)⁆ + -⁅↑L a, ↑L (b * b)⁆) +
        (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + (⁅↑L (a * a), ↑L c⁆ + -⁅↑L a, ↑L (c * c)⁆)) +
      (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + (⁅↑L (b * b), ↑L c⁆ + ⁅↑L (c * c), ↑L b⁆)) =
    0
[PROOFSTEP]
rw [← lie_skew (L (a * a)), ← lie_skew (L (b * b)), ← lie_skew (L (c * c))]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + (-⁅↑L b, ↑L (a * a)⁆ + -⁅↑L a, ↑L (b * b)⁆) +
        (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + (-⁅↑L c, ↑L (a * a)⁆ + -⁅↑L a, ↑L (c * c)⁆)) +
      (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + (-⁅↑L c, ↑L (b * b)⁆ + -⁅↑L b, ↑L (c * c)⁆)) =
    0
[PROOFSTEP]
abel
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + (-⁅↑L b, ↑L (a * a)⁆ + -⁅↑L a, ↑L (b * b)⁆) +
        (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + (-⁅↑L c, ↑L (a * a)⁆ + -⁅↑L a, ↑L (c * c)⁆)) +
      (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + (-⁅↑L c, ↑L (b * b)⁆ + -⁅↑L b, ↑L (c * c)⁆)) =
    0
[PROOFSTEP]
abel
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ 2 • (⁅↑L a, ↑L (b * c)⁆ + ⁅↑L b, ↑L (c * a)⁆ + ⁅↑L c, ↑L (a * b)⁆) = 0
[PROOFSTEP]
symm
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ 0 = 2 • (⁅↑L a, ↑L (b * c)⁆ + ⁅↑L b, ↑L (c * a)⁆ + ⁅↑L c, ↑L (a * b)⁆)
[PROOFSTEP]
calc
  0 = ⁅L (a + b + c), L ((a + b + c) * (a + b + c))⁆ := by rw [(commute_lmul_lmul_sq (a + b + c)).lie_eq]
  _ = _ := by rw [aux0, aux1, aux2, aux3, nsmul_add, nsmul_add]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ 0 = ⁅↑L (a + b + c), ↑L ((a + b + c) * (a + b + c))⁆
[PROOFSTEP]
rw [(commute_lmul_lmul_sq (a + b + c)).lie_eq]
[GOAL]
A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L (a + b + c), ↑L ((a + b + c) * (a + b + c))⁆ = 2 • (⁅↑L a, ↑L (b * c)⁆ + ⁅↑L b, ↑L (c * a)⁆ + ⁅↑L c, ↑L (a * b)⁆)
[PROOFSTEP]
rw [aux0, aux1, aux2, aux3, nsmul_add, nsmul_add]


[GOAL]
n : ℕ
A : Type u_1
R : Type u_2
inst✝³ : AddGroup A
inst✝² : Ring R
α : Type u_3
β : Type u_4
inst✝¹ : AddGroup α
a : α
inst✝ : AddAction α β
b : β
⊢ zmultiples ↑(minimalPeriod ((fun x x_1 => x +ᵥ x_1) a) b) ≤
    comap (↑(zmultiplesHom { x // x ∈ zmultiples a }) { val := a, property := (_ : a ∈ zmultiples a) })
      (stabilizer { x // x ∈ zmultiples a } b)
[PROOFSTEP]
rw [zmultiples_le, mem_comap, mem_stabilizer_iff, zmultiplesHom_apply, coe_nat_zsmul]
[GOAL]
n : ℕ
A : Type u_1
R : Type u_2
inst✝³ : AddGroup A
inst✝² : Ring R
α : Type u_3
β : Type u_4
inst✝¹ : AddGroup α
a : α
inst✝ : AddAction α β
b : β
⊢ minimalPeriod ((fun x x_1 => x +ᵥ x_1) a) b • { val := a, property := (_ : a ∈ zmultiples a) } +ᵥ b = b
[PROOFSTEP]
simp_rw [← vadd_iterate]
[GOAL]
n : ℕ
A : Type u_1
R : Type u_2
inst✝³ : AddGroup A
inst✝² : Ring R
α : Type u_3
β : Type u_4
inst✝¹ : AddGroup α
a : α
inst✝ : AddAction α β
b : β
⊢ (fun x => { val := a, property := (_ : a ∈ zmultiples a) } +ᵥ x)^[minimalPeriod (fun x => a +ᵥ x) b] b = b
[PROOFSTEP]
exact isPeriodicPt_minimalPeriod ((· +ᵥ ·) a) b
[GOAL]
n : ℕ
A : Type u_1
R : Type u_2
inst✝³ : AddGroup A
inst✝² : Ring R
α : Type u_3
β : Type u_4
inst✝¹ : AddGroup α
a : α
inst✝ : AddAction α β
b : β
⊢ Injective
    ↑(QuotientAddGroup.map (zmultiples ↑(minimalPeriod ((fun x x_1 => x +ᵥ x_1) a) b))
        (stabilizer { x // x ∈ zmultiples a } b)
        (↑(zmultiplesHom { x // x ∈ zmultiples a }) { val := a, property := (_ : a ∈ zmultiples a) })
        (_ :
          zmultiples ↑(minimalPeriod ((fun x x_1 => x +ᵥ x_1) a) b) ≤
            comap (↑(zmultiplesHom { x // x ∈ zmultiples a }) { val := a, property := (_ : a ∈ zmultiples a) })
              (stabilizer { x // x ∈ zmultiples a } b)))
[PROOFSTEP]
rw [← ker_eq_bot_iff, eq_bot_iff]
[GOAL]
n : ℕ
A : Type u_1
R : Type u_2
inst✝³ : AddGroup A
inst✝² : Ring R
α : Type u_3
β : Type u_4
inst✝¹ : AddGroup α
a : α
inst✝ : AddAction α β
b : β
⊢ ker
      (QuotientAddGroup.map (zmultiples ↑(minimalPeriod ((fun x x_1 => x +ᵥ x_1) a) b))
        (stabilizer { x // x ∈ zmultiples a } b)
        (↑(zmultiplesHom { x // x ∈ zmultiples a }) { val := a, property := (_ : a ∈ zmultiples a) })
        (_ :
          zmultiples ↑(minimalPeriod ((fun x x_1 => x +ᵥ x_1) a) b) ≤
            comap (↑(zmultiplesHom { x // x ∈ zmultiples a }) { val := a, property := (_ : a ∈ zmultiples a) })
              (stabilizer { x // x ∈ zmultiples a } b))) ≤
    ⊥
[PROOFSTEP]
refine' fun q => induction_on' q fun n hn => _
[GOAL]
n✝ : ℕ
A : Type u_1
R : Type u_2
inst✝³ : AddGroup A
inst✝² : Ring R
α : Type u_3
β : Type u_4
inst✝¹ : AddGroup α
a : α
inst✝ : AddAction α β
b : β
q : ℤ ⧸ zmultiples ↑(minimalPeriod ((fun x x_1 => x +ᵥ x_1) a) b)
n : ℤ
hn :
  ↑n ∈
    ker
      (QuotientAddGroup.map (zmultiples ↑(minimalPeriod ((fun x x_1 => x +ᵥ x_1) a) b))
        (stabilizer { x // x ∈ zmultiples a } b)
        (↑(zmultiplesHom { x // x ∈ zmultiples a }) { val := a, property := (_ : a ∈ zmultiples a) })
        (_ :
          zmultiples ↑(minimalPeriod ((fun x x_1 => x +ᵥ x_1) a) b) ≤
            comap (↑(zmultiplesHom { x // x ∈ zmultiples a }) { val := a, property := (_ : a ∈ zmultiples a) })
              (stabilizer { x // x ∈ zmultiples a } b)))
⊢ ↑n ∈ ⊥
[PROOFSTEP]
rw [mem_bot, eq_zero_iff, Int.mem_zmultiples_iff, ← zsmul_vadd_eq_iff_minimalPeriod_dvd]
[GOAL]
n✝ : ℕ
A : Type u_1
R : Type u_2
inst✝³ : AddGroup A
inst✝² : Ring R
α : Type u_3
β : Type u_4
inst✝¹ : AddGroup α
a : α
inst✝ : AddAction α β
b : β
q : ℤ ⧸ zmultiples ↑(minimalPeriod ((fun x x_1 => x +ᵥ x_1) a) b)
n : ℤ
hn :
  ↑n ∈
    ker
      (QuotientAddGroup.map (zmultiples ↑(minimalPeriod ((fun x x_1 => x +ᵥ x_1) a) b))
        (stabilizer { x // x ∈ zmultiples a } b)
        (↑(zmultiplesHom { x // x ∈ zmultiples a }) { val := a, property := (_ : a ∈ zmultiples a) })
        (_ :
          zmultiples ↑(minimalPeriod ((fun x x_1 => x +ᵥ x_1) a) b) ≤
            comap (↑(zmultiplesHom { x // x ∈ zmultiples a }) { val := a, property := (_ : a ∈ zmultiples a) })
              (stabilizer { x // x ∈ zmultiples a } b)))
⊢ n • a +ᵥ b = b
[PROOFSTEP]
exact (eq_zero_iff _).mp hn
[GOAL]
n : ℕ
A : Type u_1
R : Type u_2
inst✝³ : AddGroup A
inst✝² : Ring R
α : Type u_3
β : Type u_4
inst✝¹ : Group α
a : α
inst✝ : MulAction α β
b : β
k : ℤ
⊢ ↑(orbitZpowersEquiv a b).symm ↑k =
    { val := a, property := (_ : a ∈ zpowers a) } ^ k •
      { val := b, property := (_ : b ∈ orbit { x // x ∈ zpowers a } b) }
[PROOFSTEP]
rw [orbitZpowersEquiv_symm_apply, ZMod.coe_int_cast]
[GOAL]
n : ℕ
A : Type u_1
R : Type u_2
inst✝³ : AddGroup A
inst✝² : Ring R
α : Type u_3
β : Type u_4
inst✝¹ : Group α
a : α
inst✝ : MulAction α β
b : β
k : ℤ
⊢ { val := a, property := (_ : a ∈ zpowers a) } ^ (k % ↑(minimalPeriod ((fun x x_1 => x • x_1) a) b)) •
      { val := b, property := (_ : b ∈ orbit { x // x ∈ zpowers a } b) } =
    { val := a, property := (_ : a ∈ zpowers a) } ^ k •
      { val := b, property := (_ : b ∈ orbit { x // x ∈ zpowers a } b) }
[PROOFSTEP]
exact Subtype.ext (zpow_smul_mod_minimalPeriod _ _ k)
[GOAL]
n : ℕ
A : Type u_1
R : Type u_2
inst✝⁵ : AddGroup A
inst✝⁴ : Ring R
α✝ : Type u_3
β✝ : Type u_4
inst✝³ : Group α✝
a✝ : α✝
inst✝² : MulAction α✝ β✝
b✝ : β✝
α : Type u_5
β : Type u_6
inst✝¹ : AddGroup α
a : α
inst✝ : AddAction α β
b : β
k : ℤ
⊢ ↑(orbitZmultiplesEquiv a b).symm ↑k =
    k • { val := a, property := (_ : a ∈ zmultiples a) } +ᵥ
      { val := b, property := (_ : b ∈ AddAction.orbit { x // x ∈ zmultiples a } b) }
[PROOFSTEP]
rw [AddAction.orbit_zmultiples_equiv_symm_apply, ZMod.coe_int_cast]
  -- porting note: times out without `a b` explicit
[GOAL]
n : ℕ
A : Type u_1
R : Type u_2
inst✝⁵ : AddGroup A
inst✝⁴ : Ring R
α✝ : Type u_3
β✝ : Type u_4
inst✝³ : Group α✝
a✝ : α✝
inst✝² : MulAction α✝ β✝
b✝ : β✝
α : Type u_5
β : Type u_6
inst✝¹ : AddGroup α
a : α
inst✝ : AddAction α β
b : β
k : ℤ
⊢ (k % ↑(minimalPeriod ((fun x x_1 => x +ᵥ x_1) a) b)) • { val := a, property := (_ : a ∈ zmultiples a) } +ᵥ
      { val := b, property := (_ : b ∈ AddAction.orbit { x // x ∈ zmultiples a } b) } =
    k • { val := a, property := (_ : a ∈ zmultiples a) } +ᵥ
      { val := b, property := (_ : b ∈ AddAction.orbit { x // x ∈ zmultiples a } b) }
[PROOFSTEP]
exact Subtype.ext (zsmul_vadd_mod_minimalPeriod a b k)
[GOAL]
n : ℕ
A : Type u_1
R : Type u_2
inst✝⁴ : AddGroup A
inst✝³ : Ring R
α : Type u_3
β : Type u_4
inst✝² : Group α
a : α
inst✝¹ : MulAction α β
b : β
inst✝ : Fintype ↑(orbit { x // x ∈ zpowers a } b)
⊢ minimalPeriod ((fun x x_1 => x • x_1) a) b = Fintype.card ↑(orbit { x // x ∈ zpowers a } b)
[PROOFSTEP]
rw [← Fintype.ofEquiv_card (orbitZpowersEquiv a b), @ZMod.card _ (_)]
[GOAL]
n : ℕ
A : Type u_1
R : Type u_2
inst✝⁴ : AddGroup A
inst✝³ : Ring R
α : Type u_3
β : Type u_4
inst✝² : Group α
a : α
inst✝¹ : MulAction α β
b : β
inst✝ : Finite ↑(orbit { x // x ∈ zpowers a } b)
⊢ minimalPeriod ((fun x x_1 => x • x_1) a) b ≠ 0
[PROOFSTEP]
cases nonempty_fintype (orbit (zpowers a) b)
[GOAL]
case intro
n : ℕ
A : Type u_1
R : Type u_2
inst✝⁴ : AddGroup A
inst✝³ : Ring R
α : Type u_3
β : Type u_4
inst✝² : Group α
a : α
inst✝¹ : MulAction α β
b : β
inst✝ : Finite ↑(orbit { x // x ∈ zpowers a } b)
val✝ : Fintype ↑(orbit { x // x ∈ zpowers a } b)
⊢ minimalPeriod ((fun x x_1 => x • x_1) a) b ≠ 0
[PROOFSTEP]
haveI : Nonempty (orbit (zpowers a) b) := (orbit_nonempty b).to_subtype
[GOAL]
case intro
n : ℕ
A : Type u_1
R : Type u_2
inst✝⁴ : AddGroup A
inst✝³ : Ring R
α : Type u_3
β : Type u_4
inst✝² : Group α
a : α
inst✝¹ : MulAction α β
b : β
inst✝ : Finite ↑(orbit { x // x ∈ zpowers a } b)
val✝ : Fintype ↑(orbit { x // x ∈ zpowers a } b)
this : Nonempty ↑(orbit { x // x ∈ zpowers a } b)
⊢ minimalPeriod ((fun x x_1 => x • x_1) a) b ≠ 0
[PROOFSTEP]
rw [minimalPeriod_eq_card]
[GOAL]
case intro
n : ℕ
A : Type u_1
R : Type u_2
inst✝⁴ : AddGroup A
inst✝³ : Ring R
α : Type u_3
β : Type u_4
inst✝² : Group α
a : α
inst✝¹ : MulAction α β
b : β
inst✝ : Finite ↑(orbit { x // x ∈ zpowers a } b)
val✝ : Fintype ↑(orbit { x // x ∈ zpowers a } b)
this : Nonempty ↑(orbit { x // x ∈ zpowers a } b)
⊢ Fintype.card ↑(orbit { x // x ∈ zpowers a } b) ≠ 0
[PROOFSTEP]
exact Fintype.card_ne_zero
[GOAL]
n : ℕ
A : Type u_1
R : Type u_2
inst✝² : AddGroup A
inst✝¹ : Ring R
α : Type u_3
inst✝ : Group α
a : α
⊢ orderOf a = Nat.card { x // x ∈ zpowers a }
[PROOFSTEP]
have := Nat.card_congr (MulAction.orbitZpowersEquiv a (1 : α))
[GOAL]
n : ℕ
A : Type u_1
R : Type u_2
inst✝² : AddGroup A
inst✝¹ : Ring R
α : Type u_3
inst✝ : Group α
a : α
this :
  Nat.card ↑(MulAction.orbit { x // x ∈ zpowers a } 1) =
    Nat.card (ZMod (Function.minimalPeriod ((fun x x_1 => x • x_1) a) 1))
⊢ orderOf a = Nat.card { x // x ∈ zpowers a }
[PROOFSTEP]
rwa [Nat.card_zmod, orbit_subgroup_one_eq_self, eq_comm] at this
[GOAL]
n : ℕ
A : Type u_1
R : Type u_2
inst✝² : AddGroup A
inst✝¹ : Ring R
α : Type u_3
inst✝ : Group α
a : α
h : IsOfFinOrder a
⊢ Finite { x // x ∈ zpowers a }
[PROOFSTEP]
rw [← orderOf_pos_iff, order_eq_card_zpowers'] at h
[GOAL]
n : ℕ
A : Type u_1
R : Type u_2
inst✝² : AddGroup A
inst✝¹ : Ring R
α : Type u_3
inst✝ : Group α
a : α
h : 0 < Nat.card { x // x ∈ zpowers a }
⊢ Finite { x // x ∈ zpowers a }
[PROOFSTEP]
exact Nat.finite_of_card_ne_zero h.ne.symm


[GOAL]
S✝ : Type u'
T : Type u''
R✝ : Type u
M✝ : Type v
inst✝⁵ : SMul R✝ M✝
inst✝⁴ : SetLike S✝ M✝
hS : SMulMemClass S✝ R✝ M✝
s : S✝
R : Type u_1
M : Type u_2
S : Type u_3
inst✝³ : Monoid R
inst✝² : MulAction R M
inst✝¹ : SetLike S M
inst✝ : SMulMemClass S R M
N : S
x : M
h : ∀ (a : R), a • x ∈ N
⊢ x ∈ N
[PROOFSTEP]
simpa using h 1
[GOAL]
S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝ : SMul R M
p q : SubMulAction R M
h : p.carrier = q.carrier
⊢ p = q
[PROOFSTEP]
cases p
[GOAL]
case mk
S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝ : SMul R M
q : SubMulAction R M
carrier✝ : Set M
smul_mem'✝ : ∀ (c : R) {x : M}, x ∈ carrier✝ → c • x ∈ carrier✝
h : { carrier := carrier✝, smul_mem' := smul_mem'✝ }.carrier = q.carrier
⊢ { carrier := carrier✝, smul_mem' := smul_mem'✝ } = q
[PROOFSTEP]
cases q
[GOAL]
case mk.mk
S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝ : SMul R M
carrier✝¹ : Set M
smul_mem'✝¹ : ∀ (c : R) {x : M}, x ∈ carrier✝¹ → c • x ∈ carrier✝¹
carrier✝ : Set M
smul_mem'✝ : ∀ (c : R) {x : M}, x ∈ carrier✝ → c • x ∈ carrier✝
h :
  { carrier := carrier✝¹, smul_mem' := smul_mem'✝¹ }.carrier = { carrier := carrier✝, smul_mem' := smul_mem'✝ }.carrier
⊢ { carrier := carrier✝¹, smul_mem' := smul_mem'✝¹ } = { carrier := carrier✝, smul_mem' := smul_mem'✝ }
[PROOFSTEP]
congr
[GOAL]
S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝ : SMul R M
p : SubMulAction R M
r : R
x : M
⊢ { x // x ∈ p } →[R] M
[PROOFSTEP]
refine' { toFun := Subtype.val .. }
[GOAL]
S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝ : SMul R M
p : SubMulAction R M
r : R
x : M
⊢ ∀ (m : R) (x : { x // x ∈ p }), ↑(m • x) = m • ↑x
[PROOFSTEP]
simp [val_smul]
[GOAL]
S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝⁴ : Monoid R
inst✝³ : MulAction R M
inst✝² : SMul S R
inst✝¹ : SMul S M
inst✝ : IsScalarTower S R M
p : SubMulAction R M
s : S
x : M
h : x ∈ p
⊢ s • x ∈ p
[PROOFSTEP]
rw [← one_smul R x, ← smul_assoc]
[GOAL]
S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝⁴ : Monoid R
inst✝³ : MulAction R M
inst✝² : SMul S R
inst✝¹ : SMul S M
inst✝ : IsScalarTower S R M
p : SubMulAction R M
s : S
x : M
h : x ∈ p
⊢ (s • 1) • x ∈ p
[PROOFSTEP]
exact p.smul_mem _ h
[GOAL]
S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝¹ : Monoid R
inst✝ : MulAction R M
p : SubMulAction R M
m : { x // x ∈ p }
⊢ MulAction.Stabilizer.submonoid R m = MulAction.Stabilizer.submonoid R ↑m
[PROOFSTEP]
ext
[GOAL]
case h
S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝¹ : Monoid R
inst✝ : MulAction R M
p : SubMulAction R M
m : { x // x ∈ p }
x✝ : R
⊢ x✝ ∈ MulAction.Stabilizer.submonoid R m ↔ x✝ ∈ MulAction.Stabilizer.submonoid R ↑m
[PROOFSTEP]
simp only [MulAction.mem_stabilizer_submonoid_iff, ← SubMulAction.val_smul, SetLike.coe_eq_coe]
[GOAL]
S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝¹ : Group R
inst✝ : MulAction R M
p : SubMulAction R M
m : { x // x ∈ p }
⊢ MulAction.stabilizer R m = MulAction.stabilizer R ↑m
[PROOFSTEP]
rw [← Subgroup.toSubmonoid_eq]
[GOAL]
S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝¹ : Group R
inst✝ : MulAction R M
p : SubMulAction R M
m : { x // x ∈ p }
⊢ (MulAction.stabilizer R m).toSubmonoid = (MulAction.stabilizer R ↑m).toSubmonoid
[PROOFSTEP]
exact stabilizer_of_subMul.submonoid m
[GOAL]
S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : SubMulAction R M
r : R
x y : M
hx : x ∈ p
⊢ -x ∈ p
[PROOFSTEP]
rw [← neg_one_smul R]
[GOAL]
S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : SubMulAction R M
r : R
x y : M
hx : x ∈ p
⊢ -1 • x ∈ p
[PROOFSTEP]
exact p.smul_mem _ hx
[GOAL]
S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : SubMulAction R M
r : R
x y : M
h : -x ∈ p
⊢ x ∈ p
[PROOFSTEP]
rw [← neg_neg x]
[GOAL]
S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : SubMulAction R M
r : R
x y : M
h : -x ∈ p
⊢ - -x ∈ p
[PROOFSTEP]
exact neg_mem _ h