l3lab/ntp-mathlib huggingface dataset:
/-- 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 ((_ | _) | (_ | _)) <;>
    

Proof state:
case property.refine'_3.mk.single.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
⊢ (m ≫ F.val.map (eqToHom (_ : iSup ι = U ⊔ V)).op) ≫
      ((presheaf F).mapCone (Cocone.op (Pairwise.cocone ι))).π.app
        { unop := Pairwise.single { down := WalkingPair.left } } =
    (interUnionPullbackConeLift F U V s ≫ F.val.map (eqToHom (_ : iSup ι = U ⊔ V)).op) ≫
      ((presheaf F).mapCone (Cocone.op (Pairwise.cocone ι))).π.app
        { unop := Pairwise.single { down := WalkingPair.left } }

Next tactic:
rw [Category.assoc, Category.assoc]
/-- 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 ((_ | _) | (_ | _)) <;>
    

Proof state:
case property.refine'_3.mk.single.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
⊢ (m ≫ F.val.map (eqToHom (_ : iSup ι = U ⊔ V)).op) ≫
      ((presheaf F).mapCone (Cocone.op (Pairwise.cocone ι))).π.app
        { unop := Pairwise.single { down := WalkingPair.right } } =
    (interUnionPullbackConeLift F U V s ≫ F.val.map (eqToHom (_ : iSup ι = U ⊔ V)).op) ≫
      ((presheaf F).mapCone (Cocone.op (Pairwise.cocone ι))).π.app
        { unop := Pairwise.single { down := WalkingPair.right } }

Next tactic:
rw [Category.assoc, Category.assoc]
/-- 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 ((_ | _) | (_ | _)) <;>
    

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✝ }

Next tactic:
rw [Category.assoc, Category.assoc]
/-- 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 ((_ | _) | (_ | _)) <;>
    

Proof state:
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:
rw [Category.assoc, Category.assoc]
/-- 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]
    · 

Proof state:
case property.refine'_3.mk.single.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
⊢ m ≫
      F.val.map (eqToHom (_ : iSup ι = U ⊔ V)).op ≫
        ((presheaf F).mapCone (Cocone.op (Pairwise.cocone ι))).π.app
          { unop := Pairwise.single { down := WalkingPair.left } } =
    interUnionPullbackConeLift F U V s ≫
      F.val.map (eqToHom (_ : iSup ι = U ⊔ V)).op ≫
        ((presheaf F).mapCone (Cocone.op (Pairwise.cocone ι))).π.app
          { unop := Pairwise.single { down := WalkingPair.left } }

Next tactic:
erw [← F.1.map_comp]
/-- 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]
      

Proof state:
case property.refine'_3.mk.single.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
⊢ m ≫
      F.val.map
        ((eqToHom (_ : iSup ι = U ⊔ V)).op ≫
          (Cocone.op (Pairwise.cocone ι)).π.app { unop := Pairwise.single { down := WalkingPair.left } }) =
    interUnionPullbackConeLift F U V s ≫
      F.val.map
        ((eqToHom (_ : iSup ι = U ⊔ V)).op ≫
          (Cocone.op (Pairwise.cocone ι)).π.app { unop := Pairwise.single { down := WalkingPair.left } })

Next tactic:
convert h₁
/-- 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₁
      

Proof state:
case h.e'_3.h
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
e_1✝ :
  (s.pt ⟶ ((Pairwise.diagram ι).op ⋙ presheaf F).obj { unop := Pairwise.single { down := WalkingPair.left } }) =
    (s.pt ⟶ F.val.obj (op U))
⊢ interUnionPullbackConeLift F U V s ≫
      F.val.map
        ((eqToHom (_ : iSup ι = U ⊔ V)).op ≫
          (Cocone.op (Pairwise.cocone ι)).π.app { unop := Pairwise.single { down := WalkingPair.left } }) =
    PullbackCone.fst s

Next tactic:
apply interUnionPullbackConeLift_left
/-- 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
    · 

Proof state:
case property.refine'_3.mk.single.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
⊢ m ≫
      F.val.map (eqToHom (_ : iSup ι = U ⊔ V)).op ≫
        ((presheaf F).mapCone (Cocone.op (Pairwise.cocone ι))).π.app
          { unop := Pairwise.single { down := WalkingPair.right } } =
    interUnionPullbackConeLift F U V s ≫
      F.val.map (eqToHom (_ : iSup ι = U ⊔ V)).op ≫
        ((presheaf F).mapCone (Cocone.op (Pairwise.cocone ι))).π.app
          { unop := Pairwise.single { down := WalkingPair.right } }

Next tactic:
erw [← F.1.map_comp]
/-- 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]
      

Proof state:
case property.refine'_3.mk.single.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
⊢ m ≫
      F.val.map
        ((eqToHom (_ : iSup ι = U ⊔ V)).op ≫
          (Cocone.op (Pairwise.cocone ι)).π.app { unop := Pairwise.single { down := WalkingPair.right } }) =
    interUnionPullbackConeLift F U V s ≫
      F.val.map
        ((eqToHom (_ : iSup ι = U ⊔ V)).op ≫
          (Cocone.op (Pairwise.cocone ι)).π.app { unop := Pairwise.single { down := WalkingPair.right } })

Next tactic:
convert h₂
/-- 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₂
      

Proof state:
case h.e'_3.h
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
e_1✝ :
  (s.pt ⟶ ((Pairwise.diagram ι).op ⋙ presheaf F).obj { unop := Pairwise.single { down := WalkingPair.right } }) =
    (s.pt ⟶ F.val.obj (op V))
⊢ interUnionPullbackConeLift F U V s ≫
      F.val.map
        ((eqToHom (_ : iSup ι = U ⊔ V)).op ≫
          (Cocone.op (Pairwise.cocone ι)).π.app { unop := Pairwise.single { down := WalkingPair.right } }) =
    PullbackCone.snd s

Next tactic:
apply interUnionPullbackConeLift_right
/-- 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
    all_goals
      

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✝ }

Next tactic:
dsimp only [Functor.op, Pairwise.cocone_ι_app, Functor.mapCone_π_app, Cocone.op,
        Pairwise.coconeιApp, unop_op, op_comp, NatTrans.op]