/-- We show that the forgetful functor `CommSemiRingCat ⥤ SemiRingCat` creates limits.

All we need to do is notice that the limit point has a `CommSemiring` instance available,
and then reuse the existing limit.
-/
instance (F : J ⥤ CommSemiRingCatMax.{v, u}) :
    CreatesLimit F (forget₂ CommSemiRingCatMax.{v, u} SemiRingCatMax.{v, u}) :=
  -- Porting note : `CommSemiRingCat ⥤ Type` reflecting isomorphism is needed to make Lean see that
  -- `CommSemiRingCat ⥤ SemiRingCat` reflects isomorphism. `CommSemiRingCat ⥤ Type` reflecting
  -- isomorphism is added manually since Lean can't see it, but even with this addition Lean can not
  -- see `CommSemiRingCat ⥤ SemiRingCat` reflects isomorphism, so this instance is also added.
  letI : ReflectsIsomorphisms (forget CommSemiRingCatMax.{v, u}) :=
    CommSemiRingCat.forgetReflectIsos.{max v u}
  letI : ReflectsIsomorphisms
    (forget₂ CommSemiRingCatMax.{v, u} SemiRingCatMax.{v, u}) :=
    CategoryTheory.reflectsIsomorphisms_forget₂ CommSemiRingCatMax.{v, u} SemiRingCatMax.{v, u}
  let c : Cone F :=
    { pt := CommSemiRingCat.of (Types.limitCone (F ⋙ forget _)).pt
      π :=
        { app := fun j => CommSemiRingCat.ofHom <| SemiRingCat.limitπRingHom.{v, u} (J := J)
            (F ⋙ forget₂ CommSemiRingCatMax.{v, u} SemiRingCatMax.{v, u}) j
          naturality := (SemiRingCat.HasLimits.limitCone.{v, u}
            (F ⋙ forget₂ CommSemiRingCatMax.{v, u} SemiRingCatMax.{v, u})).π.naturality } }
  createsLimitOfReflectsIso fun c' t =>
    { liftedCone := c
      validLift := IsLimit.uniqueUpToIso (SemiRingCat.HasLimits.limitConeIsLimit.{v, u} _) t
      makesLimit := by
        refine IsLimit.ofFaithful (forget₂ CommSemiRingCatMax.{v, u} SemiRingCatMax.{v, u})
          (SemiRingCat.HasLimits.limitConeIsLimit.{v, u} _)
          (fun s : Cone F => CommSemiRingCat.ofHom
            { toFun := _
              map_one' := Subtype.ext <| funext fun j => by exact (s.π.app j).map_one
              map_mul' := fun x y => Subtype.ext <| funext fun j => by exact (s.π.app j).map_mul x y
              map_zero' := Subtype.ext <| funext fun j => by 

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CommSemiRingCatMax
this✝ : ReflectsIsomorphisms (forget CommSemiRingCatMax) := forgetReflectIsos
this : ReflectsIsomorphisms (forget₂ CommSemiRingCatMax SemiRingCatMax) :=
  reflectsIsomorphisms_forget₂ CommSemiRingCatMax SemiRingCatMax
c : Cone F :=
  { pt := of (Types.limitCone (F ⋙ forget CommSemiRingCatMax)).pt,
    π := NatTrans.mk fun j => ofHom (SemiRingCat.limitπRingHom (F ⋙ forget₂ CommSemiRingCatMax SemiRingCatMax) j) }
c' : Cone (F ⋙ forget₂ CommSemiRingCatMax SemiRingCatMax)
t : IsLimit c'
s : Cone F
j : J
⊢ ↑(OneHom.toFun
          (↑{
              toOneHom :=
                {
                  toFun := fun v =>
                    {
                      val := fun j =>
                        ((forget SemiRingCatMax).mapCone ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                          j v,
                      property :=
                        (_ :
                          ∀ {j j' : J} (f : j ⟶ j'),
                            (((forget SemiRingCatMax).mapCone
                                          ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                    j ≫
                                  ((F ⋙ forget₂ CommSemiRingCatMax SemiRingCatMax) ⋙ forget SemiRingCatMax).map f)
                                v =
                              ((forget SemiRingCatMax).mapCone
                                      ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                j' v) },
                  map_one' :=
                    (_ :
                      {
                          val := fun j =>
                            ((forget SemiRingCatMax).mapCone
                                    ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                              j 1,
                          property :=
                            (_ :
                              ∀ {j j' : J} (f : j ⟶ j'),
                                (((forget SemiRingCatMax).mapCone
                                              ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                        j ≫
                                      ((F ⋙ forget₂ CommSemiRingCatMax SemiRingCatMax) ⋙ forget SemiRingCatMax).map f)
                                    1 =
                                  ((forget SemiRingCatMax).mapCone
                                          ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                    j' 1) } =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : ↑s.1),
                    OneHom.toFun
                        {
                          toFun := fun v =>
                            {
                              val := fun j =>
                                ((forget SemiRingCatMax).mapCone
                                        ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                  j v,
                              property :=
                                (_ :
                                  ∀ {j j' : J} (f : j ⟶ j'),
                                    (((forget SemiRingCatMax).mapCone
                                                  ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                            j ≫
                                          ((F ⋙ forget₂ CommSemiRingCatMax SemiRingCatMax) ⋙ forget SemiRingCatMax).map
                                            f)
                                        v =
                                      ((forget SemiRingCatMax).mapCone
                                              ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                        j' v) },
                          map_one' :=
                            (_ :
                              {
                                  val := fun j =>
                                    ((forget SemiRingCatMax).mapCone
                                            ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                      j 1,
                                  property :=
                                    (_ :
                                      ∀ {j j' : J} (f : j ⟶ j'),
                                        (((forget SemiRingCatMax).mapCone
                                                      ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                                j ≫
                                              ((F ⋙ forget₂ CommSemiRingCatMax SemiRingCatMax) ⋙
                                                    forget SemiRingCatMax).map
                                                f)
                                            1 =
                                          ((forget SemiRingCatMax).mapCone
                                                  ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                            j' 1) } =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun v =>
                              {
                                val := fun j =>
                                  ((forget SemiRingCatMax).mapCone
                                          ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                    j v,
                                property :=
                                  (_ :
                                    ∀ {j j' : J} (f : j ⟶ j'),
                                      (((forget SemiRingCatMax).mapCone
                                                    ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                              j ≫
                                            ((F ⋙ forget₂ CommSemiRingCatMax SemiRingCatMax) ⋙
                                                  forget SemiRingCatMax).map
                                              f)
                                          v =
                                        ((forget SemiRingCatMax).mapCone
                                                ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                          j' v) },
                            map_one' :=
                              (_ :
                                {
                                    val := fun j =>
                                      ((forget SemiRingCatMax).mapCone
                                              ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                        j 1,
                                    property :=
                                      (_ :
                                        ∀ {j j' : J} (f : j ⟶ j'),
                                          (((forget SemiRingCatMax).mapCone
                                                        ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                                  j ≫
                                                ((F ⋙ forget₂ CommSemiRingCatMax SemiRingCatMax) ⋙
                                                      forget SemiRingCatMax).map
                                                  f)
                                              1 =
                                            ((forget SemiRingCatMax).mapCone
                                                    ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                              j' 1) } =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun v =>
                              {
                                val := fun j =>
                                  ((forget SemiRingCatMax).mapCone
                                          ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                    j v,
                                property :=
                                  (_ :
                                    ∀ {j j' : J} (f : j ⟶ j'),
                                      (((forget SemiRingCatMax).mapCone
                                                    ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                              j ≫
                                            ((F ⋙ forget₂ CommSemiRingCatMax SemiRingCatMax) ⋙
                                                  forget SemiRingCatMax).map
                                              f)
                                          v =
                                        ((forget SemiRingCatMax).mapCone
                                                ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                          j' v) },
                            map_one' :=
                              (_ :
                                {
                                    val := fun j =>
                                      ((forget SemiRingCatMax).mapCone
                                              ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                        j 1,
                                    property :=
                                      (_ :
                                        ∀ {j j' : J} (f : j ⟶ j'),
                                          (((forget SemiRingCatMax).mapCone
                                                        ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                                  j ≫
                                                ((F ⋙ forget₂ CommSemiRingCatMax SemiRingCatMax) ⋙
                                                      forget SemiRingCatMax).map
                                                  f)
                                              1 =
                                            ((forget SemiRingCatMax).mapCone
                                                    ((forget₂ CommSemiRingCatMax SemiRingCatMax).mapCone s)).π.app
                                              j' 1) } =
                                  1) }
                          y) })
          0)
      j =
    ↑0 j

Next tactic:
exact (s.π.app j).map_zero