Theorem: TopCat.Presheaf.SheafConditionPairwiseIntersections.coneEquivInverseObj_pt
File: Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
⊢ (X_1 : (CategoryTheory.Pairwise ι)ᵒᵖ) →
    ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).obj X_1 ⟶ ((diagram U).op ⋙ F).obj X_1
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
x : (CategoryTheory.Pairwise ι)ᵒᵖ
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).obj x ⟶ ((diagram U).op ⋙ F).obj x
tactic: intro x
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
x : (CategoryTheory.Pairwise ι)ᵒᵖ
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).obj x ⟶ ((diagram U).op ⋙ F).obj x
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
x : CategoryTheory.Pairwise ι
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).obj (op x) ⟶ ((diagram U).op ⋙ F).obj (op x)
tactic: induction x using Opposite.rec' with | h x => ?_
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
x : CategoryTheory.Pairwise ι
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).obj (op x) ⟶ ((diagram U).op ⋙ F).obj (op x)
state_after: case h.single
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
i : ι
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).obj (op (single i)) ⟶
    ((diagram U).op ⋙ F).obj (op (single i))

case h.pair
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
i j : ι
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).obj (op (Pairwise.pair i j)) ⟶
    ((diagram U).op ⋙ F).obj (op (Pairwise.pair i j))
tactic: rcases x with (⟨i⟩ | ⟨i, j⟩)
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
⊢ ∀ ⦃X_1 Y : (CategoryTheory.Pairwise ι)ᵒᵖ⦄ (f : X_1 ⟶ Y),
    ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map f ≫
        Opposite.rec'
          (fun x =>
            Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i)
              fun i j => c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
          Y =
      Opposite.rec'
          (fun x =>
            Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i)
              fun i j => c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
          X_1 ≫
        ((diagram U).op ⋙ F).map f
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
x y : (CategoryTheory.Pairwise ι)ᵒᵖ
f : x ⟶ y
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map f ≫
      Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        y =
    Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        x ≫
      ((diagram U).op ⋙ F).map f
tactic: intro x y f
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
x y : (CategoryTheory.Pairwise ι)ᵒᵖ
f : x ⟶ y
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map f ≫
      Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        y =
    Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        x ≫
      ((diagram U).op ⋙ F).map f
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
y : (CategoryTheory.Pairwise ι)ᵒᵖ
x : CategoryTheory.Pairwise ι
f : op x ⟶ y
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map f ≫
      Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        y =
    Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op x) ≫
      ((diagram U).op ⋙ F).map f
tactic: induction x using Opposite.rec' with | h x => ?_
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
y : (CategoryTheory.Pairwise ι)ᵒᵖ
x : CategoryTheory.Pairwise ι
f : op x ⟶ y
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map f ≫
      Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        y =
    Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op x) ≫
      ((diagram U).op ⋙ F).map f
state_after: case h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
x y : CategoryTheory.Pairwise ι
f : op x ⟶ op y
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map f ≫
      Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op y) =
    Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op x) ≫
      ((diagram U).op ⋙ F).map f
tactic: induction y using Opposite.rec' with | h y => ?_
state_before: case h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
x y : CategoryTheory.Pairwise ι
f : op x ⟶ op y
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map f ≫
      Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op y) =
    Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op x) ≫
      ((diagram U).op ⋙ F).map f
state_after: case h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
x y : CategoryTheory.Pairwise ι
f : op x ⟶ op y
ef : f = f.unop.op
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map f ≫
      Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op y) =
    Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op x) ≫
      ((diagram U).op ⋙ F).map f
tactic: have ef : f = f.unop.op := rfl
state_before: case h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
x y : CategoryTheory.Pairwise ι
f : op x ⟶ op y
ef : f = f.unop.op
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map f ≫
      Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op y) =
    Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op x) ≫
      ((diagram U).op ⋙ F).map f
state_after: case h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
x y : CategoryTheory.Pairwise ι
f : op x ⟶ op y
⊢ f = f.unop.op →
    ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map f ≫
        Opposite.rec'
          (fun x =>
            Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i)
              fun i j => c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
          (op y) =
      Opposite.rec'
          (fun x =>
            Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i)
              fun i j => c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
          (op x) ≫
        ((diagram U).op ⋙ F).map f
tactic: revert ef
state_before: case h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
x y : CategoryTheory.Pairwise ι
f : op x ⟶ op y
⊢ f = f.unop.op →
    ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map f ≫
        Opposite.rec'
          (fun x =>
            Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i)
              fun i j => c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
          (op y) =
      Opposite.rec'
          (fun x =>
            Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i)
              fun i j => c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
          (op x) ≫
        ((diagram U).op ⋙ F).map f
state_after: case h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
x y : CategoryTheory.Pairwise ι
f : op x ⟶ op y
f' : unop (op y) ⟶ unop (op x)
⊢ f = f'.op →
    ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map f ≫
        Opposite.rec'
          (fun x =>
            Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i)
              fun i j => c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
          (op y) =
      Opposite.rec'
          (fun x =>
            Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i)
              fun i j => c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
          (op x) ≫
        ((diagram U).op ⋙ F).map f
tactic: generalize f.unop = f'
state_before: case h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
x y : CategoryTheory.Pairwise ι
f : op x ⟶ op y
f' : unop (op y) ⟶ unop (op x)
⊢ f = f'.op →
    ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map f ≫
        Opposite.rec'
          (fun x =>
            Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i)
              fun i j => c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
          (op y) =
      Opposite.rec'
          (fun x =>
            Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i)
              fun i j => c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
          (op x) ≫
        ((diagram U).op ⋙ F).map f
state_after: case h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
x y : CategoryTheory.Pairwise ι
f' : unop (op y) ⟶ unop (op x)
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map f'.op ≫
      Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op y) =
    Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op x) ≫
      ((diagram U).op ⋙ F).map f'.op
tactic: rintro rfl
state_before: case h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
x y : CategoryTheory.Pairwise ι
f' : unop (op y) ⟶ unop (op x)
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map f'.op ≫
      Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op y) =
    Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op x) ≫
      ((diagram U).op ⋙ F).map f'.op
state_after: case h.h.single.single.id_single
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
i : ι
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map (Quiver.Hom.op (id_single i)) ≫
      Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op (single i)) =
    Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op (single i)) ≫
      ((diagram U).op ⋙ F).map (Quiver.Hom.op (id_single i))

case h.h.single.pair.left
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
i j : ι
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map (Quiver.Hom.op (left i j)) ≫
      Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op (Pairwise.pair i j)) =
    Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op (single i)) ≫
      ((diagram U).op ⋙ F).map (Quiver.Hom.op (left i j))

case h.h.single.pair.right
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
i j : ι
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map (Quiver.Hom.op (right j i)) ≫
      Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op (Pairwise.pair j i)) =
    Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op (single i)) ≫
      ((diagram U).op ⋙ F).map (Quiver.Hom.op (right j i))

case h.h.pair.pair.id_pair
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone (SheafConditionEqualizerProducts.diagram F U)
a✝¹ a✝ : ι
⊢ ((Functor.const (CategoryTheory.Pairwise ι)ᵒᵖ).obj c.pt).map (Quiver.Hom.op (id_pair a✝¹ a✝)) ≫
      Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op (Pairwise.pair a✝¹ a✝)) =
    Opposite.rec'
        (fun x =>
          Pairwise.casesOn x (fun i => c.π.app WalkingParallelPair.zero ≫ Pi.π (fun i => F.obj (op (U i))) i) fun i j =>
            c.π.app WalkingParallelPair.one ≫ Pi.π (fun p => F.obj (op (U p.1 ⊓ U p.2))) (i, j))
        (op (Pairwise.pair a✝¹ a✝)) ≫
      ((diagram U).op ⋙ F).map (Quiver.Hom.op (id_pair a✝¹ a✝))
tactic: rcases x with (⟨i⟩ | ⟨⟩) <;> rcases y with (⟨⟩ | ⟨j, j⟩) <;> rcases f' with ⟨⟩