-- Lean 4 proof step from Mathlib.Algebra.Category.Ring.FinitePresentation (goal)
Goal:
J : Type uJ
inst : Category.{vJ, uJ} J
inst_1 : IsFiltered.{vJ, uJ} J
R : CommRingCat
F : CategoryTheory.Functor.{vJ, u, uJ, u + 1} J CommRingCat
α : Functor.obj (Functor.const J) R ⟶ F
S : CommRingCat
f : R ⟶ S
c : Cocone F
hc : IsColimit c
inst_2 :
  PreservesColimit F
    (forget CommRingCat (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
      CommRingCat.carrier))
hf : (CommRingCat.Hom.hom f).FinitePresentation
g : S ⟶ c.pt
hg : ∀ (i : J), f ≫ g = α.app i ≫ c.ι.app i
have have₁ have₂ have₃ :
  ∀
    (hc' :
      IsColimit (F :=
        F ⋙
          forget CommRingCat (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
            CommRingCat.carrier))
        (Functor.mapCocone
          (forget CommRingCat (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
            CommRingCat.carrier))
          c)),
    ∃ (i : J) (g' : S ⟶ F.obj i), f ≫ g' = α.app i ∧ g = g' ≫ c.ι.app i
have₄ have₅ have₆ :
  ∀
    (hc' :
      IsColimit (F :=
        F ⋙
          forget CommRingCat (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
            CommRingCat.carrier))
        (Functor.mapCocone
          (forget CommRingCat (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
            CommRingCat.carrier))
          c))
    (n : ℕ)
    (hn :
      ∃ (f_1 : MvPolynomial (Fin n) (↑R : Type u) →ₐ[(↑R : Type u)] (↑S : Type u)),
        Function.Surjective (α := MvPolynomial (Fin n) (↑R : Type u)) (β := (↑S : Type u))
            (⇑f_1 : (a : MvPolynomial (Fin n) (↑R : Type u)) → (↑S : Type u)) ∧
          Ideal.FG (ker f_1.toRingHom)),
    ∃ (i : J) (g' : S ⟶ F.obj i), f ≫ g' = α.app i ∧ g = g' ≫ c.ι.app i
have₇ :
  ∀
    (hc' :
      IsColimit (F :=
        F ⋙
          forget CommRingCat (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
            CommRingCat.carrier))
        (Functor.mapCocone
          (forget CommRingCat (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
            CommRingCat.carrier))
          c))
    (n : ℕ),
    let P := CommRingCat.of (MvPolynomial (Fin n) (↑R : Type u));
    let iP : R ⟶ P := CommRingCat.ofHom MvPolynomial.C;
    ∀ (π : P ⟶ S) (hg : ∀ (i : J), (iP ≫ π) ≫ g = α.app i ≫ c.ι.app i)
      (hn :
        ∃ (f : MvPolynomial (Fin n) (↑R : Type u) →ₐ[(↑R : Type u)] (↑S : Type u)),
          Function.Surjective (α := MvPolynomial (Fin n) (↑R : Type u)) (β := (↑S : Type u))
              (⇑f : (a : MvPolynomial (Fin n) (↑R : Type u)) → (↑S : Type u)) ∧
            Ideal.FG (ker f.toRingHom))
      (hπ :
        Function.Surjective (α := (↑P : Type u)) (β := (↑S : Type u))
          (⇑(ConcreteCategory.hom (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
                CommRingCat.carrier) π) :
            (a : (↑P : Type u)) → (↑S : Type u)))
      (s : Finset (↑P : Type u))
      (hs : Eq (α := Ideal (↑P : Type u)) (Ideal.span (↑s : Set (↑P : Type u))) (ker (CommRingCat.Hom.hom π))),
      ∃ (i : J) (g' : S ⟶ F.obj i), (iP ≫ π) ≫ g' = α.app i ∧ g = g' ≫ c.ι.app i
have₈ :
  ∀
    (hc' :
      IsColimit (F :=
        F ⋙
          forget CommRingCat (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
            CommRingCat.carrier))
        (Functor.mapCocone
          (forget CommRingCat (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
            CommRingCat.carrier))
          c))
    (n : ℕ),
    let P := CommRingCat.of (MvPolynomial (Fin n) (↑R : Type u));
    let iP : R ⟶ P := CommRingCat.ofHom MvPolynomial.C;
    ∀ (π : P ⟶ S) (hg : ∀ (i : J), (iP ≫ π) ≫ g = α.app i ≫ c.ι.app i)
      (hn :
        ∃ (f : MvPolynomial (Fin n) (↑R : Type u) →ₐ[(↑R : Type u)] (↑S : Type u)),
          Function.Surjective (α := MvPolynomial (Fin n) (↑R : Type u)) (β := (↑S : Type u))
              (⇑f : (a : MvPolynomial (Fin n) (↑R : Type u)) → (↑S : Type u)) ∧
            Ideal.FG (ker f.toRingHom))
      (hπ :
        Function.Surjective (α := (↑P : Type u)) (β := (↑S : Type u))
          (⇑(ConcreteCategory.hom (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
                CommRingCat.carrier) π) :
            (a : (↑P : Type u)) → (↑S : Type u)))
      (s : Finset (↑P : Type u))
      (hs : Eq (α := Ideal (↑P : Type u)) (Ideal.span (↑s : Set (↑P : Type u))) (ker (CommRingCat.Hom.hom π))) (i : J)
      (g' : P ⟶ F.obj i) (hg' : π ≫ g = g' ≫ c.ι.app i) (hg'' : iP ≫ g' = α.app i),
      ∃ (i : J) (g' : S ⟶ F.obj i), (iP ≫ π) ≫ g' = α.app i ∧ g = g' ≫ c.ι.app i
have₉ :
  ∀
    (hc' :
      IsColimit (F :=
        F ⋙
          forget CommRingCat (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
            CommRingCat.carrier))
        (Functor.mapCocone
          (forget CommRingCat (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
            CommRingCat.carrier))
          c))
    (n : ℕ),
    let P := CommRingCat.of (MvPolynomial (Fin n) (↑R : Type u));
    let iP : R ⟶ P := CommRingCat.ofHom MvPolynomial.C;
    ∀ (π : P ⟶ S) (hg : ∀ (i : J), (iP ≫ π) ≫ g = α.app i ≫ c.ι.app i)
      (hn :
        ∃ (f : MvPolynomial (Fin n) (↑R : Type u) →ₐ[(↑R : Type u)] (↑S : Type u)),
          Function.Surjective (α := MvPolynomial (Fin n) (↑R : Type u)) (β := (↑S : Type u))
              (⇑f : (a : MvPolynomial (Fin n) (↑R : Type u)) → (↑S : Type u)) ∧
            Ideal.FG (ker f.toRingHom))
      (hπ :
        Function.Surjective (α := (↑P : Type u)) (β := (↑S : Type u))
          (⇑(ConcreteCategory.hom (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
                CommRingCat.carrier) π) :
            (a : (↑P : Type u)) → (↑S : Type u)))
      (s : Finset (↑P : Type u))
      (hs : Eq (α := Ideal (↑P : Type u)) (Ideal.span (↑s : Set (↑P : Type u))) (ker (CommRingCat.Hom.hom π))) (i : J)
      (g' : P ⟶ F.obj i) (hg' : π ≫ g = g' ≫ c.ι.app i) (hg'' : iP ≫ g' = α.app i)
      (this :
        ∀ (r : ↥s),
          ∃ (i' : J) (hi' : i ⟶ i'),
            Eq (α := (↑(F.obj i') : Type u))
              ((ConcreteCategory.hom (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
                      CommRingCat.carrier) (F.map hi') :
                    (a : (↑(F.obj i) : Type u)) → (↑(F.obj i') : Type u))
                  ((ConcreteCategory.hom (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
                          CommRingCat.carrier) g' :
                        (a : (↑P : Type u)) → (↑(F.obj i) : Type u))
                      (↑r : (↑P : Type u)) :
                    (↑(F.obj i) : Type u)) :
                (↑(F.obj i') : Type u))
              (0 : (↑(F.obj i') : Type u))),
      ∃ (i : J) (g' : S ⟶ F.obj i), (iP ≫ π) ≫ g' = α.app i ∧ g = g' ≫ c.ι.app i
have₁₀ :
  ∀
    (hc' :
      IsColimit (F :=
        F ⋙
          forget CommRingCat (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
            CommRingCat.carrier))
        (Functor.mapCocone
          (forget CommRingCat (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
            CommRingCat.carrier))
          c))
    (n : ℕ),
    let P := CommRingCat.of (MvPolynomial (Fin n) (↑R : Type u));
    let iP : R ⟶ P := CommRingCat.ofHom MvPolynomial.C;
    ∀ (π : P ⟶ S) (hg : ∀ (i : J), (iP ≫ π) ≫ g = α.app i ≫ c.ι.app i)
      (hn :
        ∃ (f : MvPolynomial (Fin n) (↑R : Type u) →ₐ[(↑R : Type u)] (↑S : Type u)),
          Function.Surjective (α := MvPolynomial (Fin n) (↑R : Type u)) (β := (↑S : Type u))
              (⇑f : (a : MvPolynomial (Fin n) (↑R : Type u)) → (↑S : Type u)) ∧
            Ideal.FG (ker f.toRingHom))
      (hπ :
        Function.Surjective (α := (↑P : Type u)) (β := (↑S : Type u))
          (⇑(ConcreteCategory.hom (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
                CommRingCat.carrier) π) :
            (a : (↑P : Type u)) → (↑S : Type u)))
      (s : Finset (↑P : Type u))
      (hs : Eq (α := Ideal (↑P : Type u)) (Ideal.span (↑s : Set (↑P : Type u))) (ker (CommRingCat.Hom.hom π))) (i : J)
      (g' : P ⟶ F.obj i) (hg' : π ≫ g = g' ≫ c.ι.app i) (hg'' : iP ≫ g' = α.app i) (i' : (r : ↥s) → J)
      (hi' : (r : ↥s) → i ⟶ i' r)
      (hi'' :
        ∀ (r : ↥s),
          Eq (α := (↑(F.obj (i' r)) : Type u))
            ((ConcreteCategory.hom (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
                    CommRingCat.carrier) (F.map (hi' r)) :
                  (a : (↑(F.obj i) : Type u)) → (↑(F.obj (i' r)) : Type u))
                ((ConcreteCategory.hom (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
                        CommRingCat.carrier) g' :
                      (a : (↑P : Type u)) → (↑(F.obj i) : Type u))
                    (↑r : (↑P : Type u)) :
                  (↑(F.obj i) : Type u)) :
              (↑(F.obj (i' r)) : Type u))
            (0 : (↑(F.obj (i' r)) : Type u))),
      ∃ (i : J) (g' : S ⟶ F.obj i), (iP ≫ π) ≫ g' = α.app i ∧ g = g' ≫ c.ι.app i
have₁₁ :
  ∀
    (hc' :
      IsColimit (F :=
        F ⋙
          forget CommRingCat (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
            CommRingCat.carrier))
        (Functor.mapCocone
          (forget CommRingCat (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
            CommRingCat.carrier))
          c))
    (n : ℕ),
    let P := CommRingCat.of (MvPolynomial (Fin n) (↑R : Type u));
    let iP : R ⟶ P := CommRingCat.ofHom MvPolynomial.C;
    ∀ (π : P ⟶ S) (hg : ∀ (i : J), (iP ≫ π) ≫ g = α.app i ≫ c.ι.app i)
      (hn :
        ∃ (f : MvPolynomial (Fin n) (↑R : Type u) →ₐ[(↑R : Type u)] (↑S : Type u)),
          Function.Surjective (α := MvPolynomial (Fin n) (↑R : Type u)) (β := (↑S : Type u))
              (⇑f : (a : MvPolynomial (Fin n) (↑R : Type u)) → (↑S : Type u)) ∧
            Ideal.FG (ker f.toRingHom))
      (hπ :
        Function.Surjective (α := (↑P : Type u)) (β := (↑S : Type u))
          (⇑(ConcreteCategory.hom (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
                CommRingCat.carrier) π) :
            (a : (↑P : Type u)) → (↑S : Type u)))
      (s : Finset (↑P : Type u))
      (hs : Eq (α := Ideal (↑P : Type u)) (Ideal.span (↑s : Set (↑P : Type u))) (ker (CommRingCat.Hom.hom π))) (i : J)
      (g' : P ⟶ F.obj i) (hg' : π ≫ g = g' ≫ c.ι.app i) (hg'' : iP ≫ g' = α.app i) (i' : (r : ↥s) → J)
      (hi' : (r : ↥s) → i ⟶ i' r)
      (hi'' :
        ∀ (r : ↥s),
          Eq (α := (↑(F.obj (i' r)) : Type u))
            ((ConcreteCategory.hom (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
                    CommRingCat.carrier) (F.map (hi' r)) :
                  (a : (↑(F.obj i) : Type u)) → (↑(F.obj (i' r)) : Type u))
                ((ConcreteCategory.hom (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
                        CommRingCat.carrier) g' :
                      (a : (↑P : Type u)) → (↑(F.obj i) : Type u))
                    (↑r : (↑P : Type u)) :
                  (↑(F.obj i) : Type u)) :
              (↑(F.obj (i' r)) : Type u))
            (0 : (↑(F.obj (i' r)) : Type u)))
      (c' : Cocone (WidePushoutShape.wideSpan i i' hi')),
      ∃ (i : J) (g' : S ⟶ F.obj i), (iP ≫ π) ≫ g' = α.app i ∧ g = g' ≫ c.ι.app i
⊢ ∃ (i : J) (g' : S ⟶ F.obj i), f ≫ g' = α.app i ∧ g = g' ≫ c.ι.app i
have refine_1 : ∀
  (hc' :
    IsColimit (F :=
      F ⋙
        forget CommRingCat (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
          CommRingCat.carrier))
      (Functor.mapCocone
        (forget CommRingCat (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
          CommRingCat.carrier))
        c))
  (n : ℕ),
  let P := CommRingCat.of (MvPolynomial (Fin n) (↑R : Type u));
  let iP : R ⟶ P := CommRingCat.ofHom MvPolynomial.C;
  ∀ (π : P ⟶ S) (hg : ∀ (i : J), (iP ≫ π) ≫ g = α.app i ≫ c.ι.app i)
    (hn :
      ∃ (f : MvPolynomial (Fin n) (↑R : Type u) →ₐ[(↑R : Type u)] (↑S : Type u)),
        Function.Surjective (α := MvPolynomial (Fin n) (↑R : Type u)) (β := (↑S : Type u))
            (⇑f : (a : MvPolynomial (Fin n) (↑R : Type u)) → (↑S : Type u)) ∧
          Ideal.FG (ker f.toRingHom))
    (hπ :
      Function.Surjective (α := (↑P : Type u)) (β := (↑S : Type u))
        (⇑(ConcreteCategory.hom (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
              CommRingCat.carrier) π) :
          (a : (↑P : Type u)) → (↑S : Type u)))
    (s : Finset (↑P : Type u))
    (hs : Eq (α := Ideal (↑P : Type u)) (Ideal.span (↑s : Set (↑P : Type u))) (ker (CommRingCat.Hom.hom π))) (i : J)
    (g' : P ⟶ F.obj i) (hg' : π ≫ g = g' ≫ c.ι.app i) (hg'' : iP ≫ g' = α.app i) (i' : (r : ↥s) → J)
    (hi' : (r : ↥s) → i ⟶ i' r)
    (hi'' :
      ∀ (r : ↥s),
        Eq (α := (↑(F.obj (i' r)) : Type u))
          ((ConcreteCategory.hom (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
                  CommRingCat.carrier) (F.map (hi' r)) :
                (a : (↑(F.obj i) : Type u)) → (↑(F.obj (i' r)) : Type u))
              ((ConcreteCategory.hom (FC := fun (R S : CommRingCat.{u}) ↦ (↑R : Type u) →+* (↑S : Type u)) (CC :=
                      CommRingCat.carrier) g' :
                    (a : (↑P : Type u)) → (↑(F.obj i) : Type u))
                  (↑r : (↑P : Type u)) :
                (↑(F.obj i) : Type u)) :
            (↑(F.obj (i' r)) : Type u))
          (0 : (↑(F.obj (i' r)) : Type u)))
    (c' : Cocone (WidePushoutShape.wideSpan i i' hi')),
    LE.le (α := Ideal (↑P : Type u)) (ker (CommRingCat.Hom.hom π))
      (ker (F := (↑P : Type u) →+* (↑(F.1 c'.pt) : Type u)) (CommRingCat.Hom.hom (g' ≫ F.map (c'.ι.app none))))
Tactic: classical
  have hc' := isColimitOfPreserves (forget _) hc
  letI := f.hom.toAlgebra
  obtain ⟨n, hn⟩ := hf
  let P := CommRingCat.of (MvPolynomial (Fin n) R)
  let iP : R ⟶ P := CommRingCat.ofHom MvPolynomial.C
  obtain ⟨π, rfl, hπ, s, hs⟩ :
      ∃ π : P ⟶ S, iP ≫ π = f ∧ Function.Surjective π ∧ (RingHom.ker π.hom).FG := by
    obtain ⟨π, h₁, h₂⟩ := hn
    exact ⟨CommRingCat.ofHom π, by ext1; exact π.comp_algebraMap, h₁, h₂⟩
  obtain ⟨i, g', hg', hg''⟩ : ∃ (i : J) (g' : P ⟶ F.obj i),
      π ≫ g = g' ≫ c.ι.app i ∧ iP ≫ g' = α.app i := by
    choose j x h using fun i ↦ Types.jointly_surjective_of_isColimit hc' ((π ≫ g) (.X i))
    obtain ⟨i, ⟨hi⟩⟩ : ∃ i, Nonempty (∀ a, (j a ⟶ i)) := by
      have : ∃ i, ∀ a, Nonempty (j a ⟶ i) := by
        simpa using IsFiltered.sup_objs_exists (Finset.univ.image j)
      simpa [← exists_true_iff_nonempty, Classical.skolem, -exists_const_iff] using this
    refine ⟨i, CommRingCat.ofHom (MvPolynomial.eval₂Hom
      (α.app i).hom (F.map (hi _) <| x ·)), ?_, ?_⟩
    · ext1
      apply MvPolynomial.ringHom_ext
      · simpa using fun x ↦ congr($(hg i).hom x)
      · intro i
        simp only [CommRingCat.hom_comp, RingHom.coe_comp, Function.comp_apply,
          Functor.const_obj_obj, CommRingCat.hom_ofHom, MvPolynomial.coe_eval₂Hom,
          MvPolynomial.eval₂_X]
        exact (congr($(c.w (hi i)).hom (x i)).trans (h i)).symm
    · ext x
      simp [P, iP]
  have : ∀ r : s, ∃ (i' : J) (hi' : i ⟶ i'), F.map hi' (g' r) = 0 := by
    intro r
    have := Types.FilteredColimit.isColimit_eq_iff _ hc' (xi := g' r) (j := i) (xj := (0 : F.obj i))
    suffices H : (g' ≫ c.ι.app i) r = 0 by
      obtain ⟨k, f, g, e⟩ := this.mp (by simpa using H)
      exact ⟨k, f, by simpa using e⟩
    rw [← hg']
    simp [show π r = 0 from hs.le (Ideal.subset_span r.2)]
  choose i' hi' hi'' using this
  obtain ⟨c'⟩ := IsFiltered.cocone_nonempty (WidePushoutShape.wideSpan i i' hi')
  refine ⟨c'.pt, CommRingCat.ofHom (RingHom.liftOfSurjective π.hom hπ
    ⟨(g' ≫ F.map (c'.ι.app none)).hom, ?_⟩), ?_, ?_⟩
  · rw [← hs, Ideal.span_le]
    intro r hr
    rw [← c'.w (.init ⟨r, hr⟩)]
    simp [hi'']
  · ext x
    suffices (iP ≫ g' ≫ F.map (c'.ι.app none)) x = α.app c'.pt x by
      simpa [RingHom.liftOfRightInverse_comp_apply] using this
    rw [← Category.assoc, hg'', ← NatTrans.naturality]
    simp only [Functor.const_obj_obj, Functor.const_obj_map, Category.id_comp]
  · ext x
    obtain ⟨x, rfl⟩ := hπ x
    suffices (π ≫ g) x = (g' ≫ F.map (c'.ι.app none) ≫ c.ι.app _) x by
      simpa only [CommRingCat.hom_comp, CommRingCat.hom_ofHom,
        RingHom.liftOfRightInverse_comp_apply, coe_comp, Function.comp_apply] using this
    rw [c.w, hg']
    rfl
Cleared hypotheses: f, hf, hg