/-- For a sheaf `F`, `F(U ⊔ V)` is the pullback of `F(U) ⟶ F(U ⊓ V)` and `F(V) ⟶ F(U ⊓ V)`. -/
def isLimitPullbackCone : IsLimit (interUnionPullbackCone F U V) := by
  let ι : ULift.{w} WalkingPair → Opens X := fun ⟨j⟩ => WalkingPair.casesOn j U V
  have hι : U ⊔ V = iSup ι := by
    ext
    rw [Opens.coe_iSup, Set.mem_iUnion]
    constructor
    · rintro (h | h)
      exacts [⟨⟨WalkingPair.left⟩, h⟩, ⟨⟨WalkingPair.right⟩, h⟩]
    · rintro ⟨⟨_ | _⟩, h⟩
      exacts [Or.inl h, Or.inr h]
  apply PullbackCone.isLimitAux'
  intro s
  use interUnionPullbackConeLift F U V s
  refine' ⟨_, _, _⟩
  · apply interUnionPullbackConeLift_left
  · apply interUnionPullbackConeLift_right
  · intro m h₁ h₂
    rw [← cancel_mono (F.1.map (eqToHom hι.symm).op)]
    apply (F.presheaf.isSheaf_iff_isSheafPairwiseIntersections.mp F.2 ι).some.hom_ext
    rintro ((_ | _) | (_ | _)) <;>
    rw [Category.assoc, Category.assoc]
    · erw [← F.1.map_comp]
      convert h₁
      apply interUnionPullbackConeLift_left
    · erw [← F.1.map_comp]
      convert h₂
      apply interUnionPullbackConeLift_right
    

Proof state:
case property.refine'_3.mk.pair.up.left
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
F : Sheaf C X
U V : Opens ↑X
s✝ : PullbackCone (F.val.map (homOfLE (_ : U ⊓ V ≤ U)).op) (F.val.map (homOfLE (_ : U ⊓ V ≤ V)).op)
ι : ULift.{w, 0} WalkingPair → Opens ↑X :=
  fun x =>
    match x with
    | { down := j } => WalkingPair.casesOn j U V
hι : U ⊔ V = iSup ι
s : PullbackCone (F.val.map (homOfLE (_ : U ⊓ V ≤ U)).op) (F.val.map (homOfLE (_ : U ⊓ V ≤ V)).op)
m : s.pt ⟶ (interUnionPullbackCone F U V).pt
h₁ : m ≫ PullbackCone.fst (interUnionPullbackCone F U V) = PullbackCone.fst s
h₂ : m ≫ PullbackCone.snd (interUnionPullbackCone F U V) = PullbackCone.snd s
a✝ : ULift.{w, 0} WalkingPair
⊢ m ≫
      F.val.map (eqToHom (_ : iSup ι = U ⊔ V)).op ≫
        ((presheaf F).mapCone (Cocone.op (Pairwise.cocone ι))).π.app
          { unop := Pairwise.pair { down := WalkingPair.left } a✝ } =
    interUnionPullbackConeLift F U V s ≫
      F.val.map (eqToHom (_ : iSup ι = U ⊔ V)).op ≫
        ((presheaf F).mapCone (Cocone.op (Pairwise.cocone ι))).π.app
          { unop := Pairwise.pair { down := WalkingPair.left } a✝ }
case property.refine'_3.mk.pair.up.right
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
F : Sheaf C X
U V : Opens ↑X
s✝ : PullbackCone (F.val.map (homOfLE (_ : U ⊓ V ≤ U)).op) (F.val.map (homOfLE (_ : U ⊓ V ≤ V)).op)
ι : ULift.{w, 0} WalkingPair → Opens ↑X :=
  fun x =>
    match x with
    | { down := j } => WalkingPair.casesOn j U V
hι : U ⊔ V = iSup ι
s : PullbackCone (F.val.map (homOfLE (_ : U ⊓ V ≤ U)).op) (F.val.map (homOfLE (_ : U ⊓ V ≤ V)).op)
m : s.pt ⟶ (interUnionPullbackCone F U V).pt
h₁ : m ≫ PullbackCone.fst (interUnionPullbackCone F U V) = PullbackCone.fst s
h₂ : m ≫ PullbackCone.snd (interUnionPullbackCone F U V) = PullbackCone.snd s
a✝ : ULift.{w, 0} WalkingPair
⊢ m ≫
      F.val.map (eqToHom (_ : iSup ι = U ⊔ V)).op ≫
        ((presheaf F).mapCone (Cocone.op (Pairwise.cocone ι))).π.app
          { unop := Pairwise.pair { down := WalkingPair.right } a✝ } =
    interUnionPullbackConeLift F U V s ≫
      F.val.map (eqToHom (_ : iSup ι = U ⊔ V)).op ≫
        ((presheaf F).mapCone (Cocone.op (Pairwise.cocone ι))).π.app
          { unop := Pairwise.pair { down := WalkingPair.right } a✝ }

Next tactic:
all_goals
      dsimp only [Functor.op, Pairwise.cocone_ι_app, Functor.mapCone_π_app, Cocone.op,
        Pairwise.coconeιApp, unop_op, op_comp, NatTrans.op]
      simp_rw [F.1.map_comp, ← Category.assoc]
      congr 1
      simp_rw [Category.assoc, ← F.1.map_comp]