/-- 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]
  apply pullback.hom_ext <;> 

Proof state:
case h₀
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) ≫
      pullback.fst =
    ((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)) ≫
      pullback.fst

Next tactic:
dsimp