/-- Verify that the `pushout_cocone` is indeed the colimit. -/
def pushoutCoconeIsColimit : Limits.IsColimit (pushoutCocone f g) :=
  Limits.PushoutCocone.isColimitAux' _ fun s => by
    letI := RingHom.toAlgebra f
    letI := RingHom.toAlgebra g
    letI := RingHom.toAlgebra (f ≫ s.inl)
    let f' : A →ₐ[R] s.pt :=
      { s.inl with
        commutes' := fun r => rfl }
    let g' : B →ₐ[R] s.pt :=
      { s.inr with
        commutes' := fun r => by
          change (g ≫ s.inr) r = (f ≫ s.inl) r
          congr 1
          exact
            (s.ι.naturality Limits.WalkingSpan.Hom.snd).trans
              (s.ι.naturality Limits.WalkingSpan.Hom.fst).symm }
    -- Porting note : Lean has forget why `A ⊗[R] B` makes sense
    letI : Algebra R A := f.toAlgebra
    letI : Algebra R B := g.toAlgebra
    letI : Algebra R (pushoutCocone f g).pt := show Algebra R (A ⊗[R] B) by infer_instance
    -- The factor map is a ⊗ b ↦ f(a) * g(b).
    use AlgHom.toRingHom (Algebra.TensorProduct.productMap f' g')
    simp only [pushoutCocone_inl, pushoutCocone_inr]
    

Proof state:
case property
R A B : CommRingCat
f : R ⟶ A
g : R ⟶ B
s : PushoutCocone f g
this✝⁴ : Algebra ↑R ↑A := RingHom.toAlgebra f
this✝³ : Algebra ↑R ↑B := RingHom.toAlgebra g
this✝² : Algebra ↑R ↑s.pt := RingHom.toAlgebra (f ≫ PushoutCocone.inl s)
f' : ↑A →ₐ[↑R] ↑s.pt :=
  let src := PushoutCocone.inl s;
  {
    toRingHom :=
      { toMonoidHom := ↑src, map_zero' := (_ : OneHom.toFun (↑↑src) 0 = 0),
        map_add' :=
          (_ : ∀ (x y : ↑A), OneHom.toFun (↑↑src) (x + y) = OneHom.toFun (↑↑src) x + OneHom.toFun (↑↑src) y) },
    commutes' :=
      (_ :
        ∀ (r : ↑R),
          OneHom.toFun
              (↑↑{ toMonoidHom := ↑src, map_zero' := (_ : OneHom.toFun (↑↑src) 0 = 0),
                    map_add' :=
                      (_ :
                        ∀ (x y : ↑A), OneHom.toFun (↑↑src) (x + y) = OneHom.toFun (↑↑src) x + OneHom.toFun (↑↑src) y) })
              ((algebraMap ↑R ↑A) r) =
            OneHom.toFun
              (↑↑{ toMonoidHom := ↑src, map_zero' := (_ : OneHom.toFun (↑↑src) 0 = 0),
                    map_add' :=
                      (_ :
                        ∀ (x y : ↑A), OneHom.toFun (↑↑src) (x + y) = OneHom.toFun (↑↑src) x + OneHom.toFun (↑↑src) y) })
              ((algebraMap ↑R ↑A) r)) }
g' : ↑B →ₐ[↑R] ↑s.pt :=
  let src := PushoutCocone.inr s;
  {
    toRingHom :=
      { toMonoidHom := ↑src, map_zero' := (_ : OneHom.toFun (↑↑src) 0 = 0),
        map_add' :=
          (_ : ∀ (x y : ↑B), OneHom.toFun (↑↑src) (x + y) = OneHom.toFun (↑↑src) x + OneHom.toFun (↑↑src) y) },
    commutes' := (_ : ∀ (r : ↑R), (g ≫ PushoutCocone.inr s) r = (f ≫ PushoutCocone.inl s) r) }
this✝¹ : Algebra ↑R ↑A := RingHom.toAlgebra f
this✝ : Algebra ↑R ↑B := RingHom.toAlgebra g
this : Algebra ↑R ↑(pushoutCocone f g).pt :=
  let_fun this := inferInstance;
  this
⊢ Algebra.TensorProduct.includeLeftRingHom ≫
        ↑(Algebra.TensorProduct.productMap
            {
              toRingHom :=
                { toMonoidHom := ↑(PushoutCocone.inl s),
                  map_zero' := (_ : OneHom.toFun (↑↑(PushoutCocone.inl s)) 0 = 0),
                  map_add' :=
                    (_ :
                      ∀ (x y : ↑A),
                        OneHom.toFun (↑↑(PushoutCocone.inl s)) (x + y) =
                          OneHom.toFun (↑↑(PushoutCocone.inl s)) x + OneHom.toFun (↑↑(PushoutCocone.inl s)) y) },
              commutes' :=
                (_ :
                  ∀ (r : ↑R),
                    OneHom.toFun
                        (↑↑{ toMonoidHom := ↑(PushoutCocone.inl s),
                              map_zero' := (_ : OneHom.toFun (↑↑(PushoutCocone.inl s)) 0 = 0),
                              map_add' :=
                                (_ :
                                  ∀ (x y : ↑A),
                                    OneHom.toFun (↑↑(PushoutCocone.inl s)) (x + y) =
                                      OneHom.toFun (↑↑(PushoutCocone.inl s)) x +
                                        OneHom.toFun (↑↑(PushoutCocone.inl s)) y) })
                        ((algebraMap ↑R ↑A) r) =
                      OneHom.toFun
                        (↑↑{ toMonoidHom := ↑(PushoutCocone.inl s),
                              map_zero' := (_ : OneHom.toFun (↑↑(PushoutCocone.inl s)) 0 = 0),
                              map_add' :=
                                (_ :
                                  ∀ (x y : ↑A),
                                    OneHom.toFun (↑↑(PushoutCocone.inl s)) (x + y) =
                                      OneHom.toFun (↑↑(PushoutCocone.inl s)) x +
                                        OneHom.toFun (↑↑(PushoutCocone.inl s)) y) })
                        ((algebraMap ↑R ↑A) r)) }
            {
              toRingHom :=
                { toMonoidHom := ↑(PushoutCocone.inr s),
                  map_zero' := (_ : OneHom.toFun (↑↑(PushoutCocone.inr s)) 0 = 0),
                  map_add' :=
                    (_ :
                      ∀ (x y : ↑B),
                        OneHom.toFun (↑↑(PushoutCocone.inr s)) (x + y) =
                          OneHom.toFun (↑↑(PushoutCocone.inr s)) x + OneHom.toFun (↑↑(PushoutCocone.inr s)) y) },
              commutes' := (_ : ∀ (r : ↑R), (g ≫ PushoutCocone.inr s) r = (f ≫ PushoutCocone.inl s) r) }) =
      PushoutCocone.inl s ∧
    ↑Algebra.TensorProduct.includeRight ≫
          ↑(Algebra.TensorProduct.productMap
              {
                toRingHom :=
                  { toMonoidHom := ↑(PushoutCocone.inl s),
                    map_zero' := (_ : OneHom.toFun (↑↑(PushoutCocone.inl s)) 0 = 0),
                    map_add' :=
                      (_ :
                        ∀ (x y : ↑A),
                          OneHom.toFun (↑↑(PushoutCocone.inl s)) (x + y) =
                            OneHom.toFun (↑↑(PushoutCocone.inl s)) x + OneHom.toFun (↑↑(PushoutCocone.inl s)) y) },
                commutes' :=
                  (_ :
                    ∀ (r : ↑R),
                      OneHom.toFun
                          (↑↑{ toMonoidHom := ↑(PushoutCocone.inl s),
                                map_zero' := (_ : OneHom.toFun (↑↑(PushoutCocone.inl s)) 0 = 0),
                                map_add' :=
                                  (_ :
                                    ∀ (x y : ↑A),
                                      OneHom.toFun (↑↑(PushoutCocone.inl s)) (x + y) =
                                        OneHom.toFun (↑↑(PushoutCocone.inl s)) x +
                                          OneHom.toFun (↑↑(PushoutCocone.inl s)) y) })
                          ((algebraMap ↑R ↑A) r) =
                        OneHom.toFun
                          (↑↑{ toMonoidHom := ↑(PushoutCocone.inl s),
                                map_zero' := (_ : OneHom.toFun (↑↑(PushoutCocone.inl s)) 0 = 0),
                                map_add' :=
                                  (_ :
                                    ∀ (x y : ↑A),
                                      OneHom.toFun (↑↑(PushoutCocone.inl s)) (x + y) =
                                        OneHom.toFun (↑↑(PushoutCocone.inl s)) x +
                                          OneHom.toFun (↑↑(PushoutCocone.inl s)) y) })
                          ((algebraMap ↑R ↑A) r)) }
              {
                toRingHom :=
                  { toMonoidHom := ↑(PushoutCocone.inr s),
                    map_zero' := (_ : OneHom.toFun (↑↑(PushoutCocone.inr s)) 0 = 0),
                    map_add' :=
                      (_ :
                        ∀ (x y : ↑B),
                          OneHom.toFun (↑↑(PushoutCocone.inr s)) (x + y) =
                            OneHom.toFun (↑↑(PushoutCocone.inr s)) x + OneHom.toFun (↑↑(PushoutCocone.inr s)) y) },
                commutes' := (_ : ∀ (r : ↑R), (g ≫ PushoutCocone.inr s) r = (f ≫ PushoutCocone.inl s) r) }) =
        PushoutCocone.inr s ∧
      ∀ {m : (pushoutCocone f g).pt ⟶ s.pt},
        Algebra.TensorProduct.includeLeftRingHom ≫ m = PushoutCocone.inl s →
          ↑Algebra.TensorProduct.includeRight ≫ m = PushoutCocone.inr s →
            m =
              ↑(Algebra.TensorProduct.productMap
                  {
                    toRingHom :=
                      { toMonoidHom := ↑(PushoutCocone.inl s),
                        map_zero' := (_ : OneHom.toFun (↑↑(PushoutCocone.inl s)) 0 = 0),
                        map_add' :=
                          (_ :
                            ∀ (x y : ↑A),
                              OneHom.toFun (↑↑(PushoutCocone.inl s)) (x + y) =
                                OneHom.toFun (↑↑(PushoutCocone.inl s)) x + OneHom.toFun (↑↑(PushoutCocone.inl s)) y) },
                    commutes' :=
                      (_ :
                        ∀ (r : ↑R),
                          OneHom.toFun
                              (↑↑{ toMonoidHom := ↑(PushoutCocone.inl s),
                                    map_zero' := (_ : OneHom.toFun (↑↑(PushoutCocone.inl s)) 0 = 0),
                                    map_add' :=
                                      (_ :
                                        ∀ (x y : ↑A),
                                          OneHom.toFun (↑↑(PushoutCocone.inl s)) (x + y) =
                                            OneHom.toFun (↑↑(PushoutCocone.inl s)) x +
                                              OneHom.toFun (↑↑(PushoutCocone.inl s)) y) })
                              ((algebraMap ↑R ↑A) r) =
                            OneHom.toFun
                              (↑↑{ toMonoidHom := ↑(PushoutCocone.inl s),
                                    map_zero' := (_ : OneHom.toFun (↑↑(PushoutCocone.inl s)) 0 = 0),
                                    map_add' :=
                                      (_ :
                                        ∀ (x y : ↑A),
                                          OneHom.toFun (↑↑(PushoutCocone.inl s)) (x + y) =
                                            OneHom.toFun (↑↑(PushoutCocone.inl s)) x +
                                              OneHom.toFun (↑↑(PushoutCocone.inl s)) y) })
                              ((algebraMap ↑R ↑A) r)) }
                  {
                    toRingHom :=
                      { toMonoidHom := ↑(PushoutCocone.inr s),
                        map_zero' := (_ : OneHom.toFun (↑↑(PushoutCocone.inr s)) 0 = 0),
                        map_add' :=
                          (_ :
                            ∀ (x y : ↑B),
                              OneHom.toFun (↑↑(PushoutCocone.inr s)) (x + y) =
                                OneHom.toFun (↑↑(PushoutCocone.inr s)) x + OneHom.toFun (↑↑(PushoutCocone.inr s)) y) },
                    commutes' := (_ : ∀ (r : ↑R), (g ≫ PushoutCocone.inr s) r = (f ≫ PushoutCocone.inl s) r) })

Next tactic:
constructor