/-- Given an open cover `{ Zᵢ }` of `Z`, then `X ×[Z] Y` is covered by `Xᵢ ×[Zᵢ] Yᵢ`, where
  `Xᵢ = X ×[Z] Zᵢ` and `Yᵢ = Y ×[Z] Zᵢ` is the preimage of `Zᵢ` in `X` and `Y`. -/
@[simps! J obj map]
def openCoverOfBase (𝒰 : OpenCover Z) (f : X ⟶ Z) (g : Y ⟶ Z) : OpenCover (pullback f g) := by
  apply
    (openCoverOfBase'.{u, u} 𝒰 f g).copy 𝒰.J
      (fun i =>
        pullback (pullback.snd : pullback f (𝒰.map i) ⟶ _)
          (pullback.snd : pullback g (𝒰.map i) ⟶ _))
      (fun i =>
        pullback.map _ _ _ _ pullback.fst pullback.fst (𝒰.map i) pullback.condition.symm
          pullback.condition.symm)
      ((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) fun _ => Iso.refl _
  intro i
  -- Porting note : deviated from original proof a bit so that it won't timeout.
  rw [Iso.refl_hom, Category.id_comp, openCoverOfBase'_map]
  

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map pullback.snd pullback.snd f g pullback.fst pullback.fst (OpenCover.map 𝒰 i)
      (_ : pullback.snd ≫ OpenCover.map 𝒰 i = pullback.fst ≫ f)
      (_ : pullback.snd ≫ OpenCover.map 𝒰 i = pullback.fst ≫ g) =
    (pullbackSymmetry pullback.snd pullback.snd).hom ≫
      (limit.isoLimitCone
            {
              cone :=
                PullbackCone.mk pullback.snd (pullback.fst ≫ pullback.fst)
                  (_ :
                    (pullback.snd ≫ pullback.snd) ≫
                        OpenCover.map 𝒰
                          (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst =
                      (pullback.fst ≫ pullback.fst) ≫ g),
              isLimit :=
                bigSquareIsPullback pullback.fst pullback.fst pullback.snd
                  (OpenCover.map 𝒰
                    (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst)
                  pullback.snd pullback.snd g (_ : pullback.snd ≫ pullback.snd = pullback.fst ≫ pullback.snd)
                  (_ :
                    pullback.snd ≫
                        OpenCover.map 𝒰
                          (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst =
                      pullback.fst ≫ g)
                  (PullbackCone.flipIsLimit
                    (pullbackIsPullback g
                      (OpenCover.map 𝒰
                        (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst)))
                  (PullbackCone.flipIsLimit (pullbackIsPullback pullback.snd pullback.snd)) }).inv ≫
        pullback.map
            (pullback.snd ≫
              OpenCover.map 𝒰 (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst)
            g (pullback.fst ≫ f) g
            (𝟙
              (pullback f
                (OpenCover.map 𝒰
                  (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst)))
            (𝟙 Y) (𝟙 Z)
            (_ :
              (pullback.snd ≫
                    OpenCover.map 𝒰
                      (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst) ≫
                  𝟙 Z =
                𝟙
                    (pullback f
                      (OpenCover.map 𝒰
                        (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst)) ≫
                  pullback.fst ≫ f)
            (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
          pullback.map (pullback.fst ≫ f) g f g pullback.fst (𝟙 Y) (𝟙 Z)
            (_ :
              (OpenCover.map (OpenCover.pullbackCover 𝒰 f)
                      (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst ≫
                    f) ≫
                  𝟙 Z =
                OpenCover.map (OpenCover.pullbackCover 𝒰 f)
                    (((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit.{u + 1}).symm) i).fst ≫
                  f)
            (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g)

Next tactic:
apply pullback.hom_ext