/-- 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 

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
x y : ↑s.1
j : J
⊢ ↑(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))
      j =
    ↑(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)
      j

Next tactic:
exact (s.π.app j).map_mul x y