l3lab/ntp-mathlib huggingface dataset:
/-- Implementation of `SheafConditionPairwiseIntersections.coneEquiv`. -/
@[simps]
def coneEquivInverseObj (c : Limits.Cone (SheafConditionEqualizerProducts.diagram F U)) :
    Limits.Cone ((diagram U).op ⋙ F) where
  pt := c.pt
  π :=
    { app := by
        intro x
        induction x using Opposite.rec' with | h x => ?_
        rcases x with (⟨i⟩ | ⟨i, j⟩)
        · exact c.π.app WalkingParallelPair.zero ≫ Pi.π _ i
        · exact c.π.app WalkingParallelPair.one ≫ Pi.π _ (i, j)
      naturality := by
        intro x y f
        induction x using Opposite.rec' with | h x => ?_
        induction y using Opposite.rec' with | h y => ?_
        

Proof state:
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

Next tactic:
have ef : f = f.unop.op := rfl
/-- Implementation of `SheafConditionPairwiseIntersections.coneEquiv`. -/
@[simps]
def coneEquivInverseObj (c : Limits.Cone (SheafConditionEqualizerProducts.diagram F U)) :
    Limits.Cone ((diagram U).op ⋙ F) where
  pt := c.pt
  π :=
    { app := by
        intro x
        induction x using Opposite.rec' with | h x => ?_
        rcases x with (⟨i⟩ | ⟨i, j⟩)
        · exact c.π.app WalkingParallelPair.zero ≫ Pi.π _ i
        · exact c.π.app WalkingParallelPair.one ≫ Pi.π _ (i, j)
      naturality := by
        intro x y f
        induction x using Opposite.rec' with | h x => ?_
        induction y using Opposite.rec' with | h y => ?_
        have ef : f = f.unop.op := rfl
        

Proof state:
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

Next tactic:
revert ef
/-- Implementation of `SheafConditionPairwiseIntersections.coneEquiv`. -/
@[simps]
def coneEquivInverseObj (c : Limits.Cone (SheafConditionEqualizerProducts.diagram F U)) :
    Limits.Cone ((diagram U).op ⋙ F) where
  pt := c.pt
  π :=
    { app := by
        intro x
        induction x using Opposite.rec' with | h x => ?_
        rcases x with (⟨i⟩ | ⟨i, j⟩)
        · exact c.π.app WalkingParallelPair.zero ≫ Pi.π _ i
        · exact c.π.app WalkingParallelPair.one ≫ Pi.π _ (i, j)
      naturality := by
        intro x y f
        induction x using Opposite.rec' with | h x => ?_
        induction y using Opposite.rec' with | h y => ?_
        have ef : f = f.unop.op := rfl
        revert ef
        

Proof state:
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

Next tactic:
generalize f.unop = f'
/-- Implementation of `SheafConditionPairwiseIntersections.coneEquiv`. -/
@[simps]
def coneEquivInverseObj (c : Limits.Cone (SheafConditionEqualizerProducts.diagram F U)) :
    Limits.Cone ((diagram U).op ⋙ F) where
  pt := c.pt
  π :=
    { app := by
        intro x
        induction x using Opposite.rec' with | h x => ?_
        rcases x with (⟨i⟩ | ⟨i, j⟩)
        · exact c.π.app WalkingParallelPair.zero ≫ Pi.π _ i
        · exact c.π.app WalkingParallelPair.one ≫ Pi.π _ (i, j)
      naturality := by
        intro x y f
        induction x using Opposite.rec' with | h x => ?_
        induction y using Opposite.rec' with | h y => ?_
        have ef : f = f.unop.op := rfl
        revert ef
        generalize f.unop = f'
        

Proof state:
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' : (op y).unop ⟶ (op x).unop
⊢ 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

Next tactic:
rintro rfl
/-- Implementation of `SheafConditionPairwiseIntersections.coneEquiv`. -/
@[simps]
def coneEquivInverseObj (c : Limits.Cone (SheafConditionEqualizerProducts.diagram F U)) :
    Limits.Cone ((diagram U).op ⋙ F) where
  pt := c.pt
  π :=
    { app := by
        intro x
        induction x using Opposite.rec' with | h x => ?_
        rcases x with (⟨i⟩ | ⟨i, j⟩)
        · exact c.π.app WalkingParallelPair.zero ≫ Pi.π _ i
        · exact c.π.app WalkingParallelPair.one ≫ Pi.π _ (i, j)
      naturality := by
        intro x y f
        induction x using Opposite.rec' with | h x => ?_
        induction y using Opposite.rec' with | h y => ?_
        have ef : f = f.unop.op := rfl
        revert ef
        generalize f.unop = f'
        rintro rfl
        

Proof state:
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 y).unop ⟶ (op x).unop
⊢ ((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

Next tactic:
rcases x with (⟨i⟩ | ⟨⟩)
/-- Implementation of `SheafConditionPairwiseIntersections.coneEquiv`. -/
@[simps]
def coneEquivInverseObj (c : Limits.Cone (SheafConditionEqualizerProducts.diagram F U)) :
    Limits.Cone ((diagram U).op ⋙ F) where
  pt := c.pt
  π :=
    { app := by
        intro x
        induction x using Opposite.rec' with | h x => ?_
        rcases x with (⟨i⟩ | ⟨i, j⟩)
        · exact c.π.app WalkingParallelPair.zero ≫ Pi.π _ i
        · exact c.π.app WalkingParallelPair.one ≫ Pi.π _ (i, j)
      naturality := by
        intro x y f
        induction x using Opposite.rec' with | h x => ?_
        induction y using Opposite.rec' with | h y => ?_
        have ef : f = f.unop.op := rfl
        revert ef
        generalize f.unop = f'
        rintro rfl
        rcases x with (⟨i⟩ | ⟨⟩) <;> 

Proof state:
case h.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)
y : CategoryTheory.Pairwise ι
i : ι
f' : (op y).unop ⟶ (op (single i)).unop
⊢ ((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 (single i)) ≫
      ((diagram U).op ⋙ F).map f'.op

Next tactic:
rcases y with (⟨⟩ | ⟨j, j⟩)
/-- Implementation of `SheafConditionPairwiseIntersections.coneEquiv`. -/
@[simps]
def coneEquivInverseObj (c : Limits.Cone (SheafConditionEqualizerProducts.diagram F U)) :
    Limits.Cone ((diagram U).op ⋙ F) where
  pt := c.pt
  π :=
    { app := by
        intro x
        induction x using Opposite.rec' with | h x => ?_
        rcases x with (⟨i⟩ | ⟨i, j⟩)
        · exact c.π.app WalkingParallelPair.zero ≫ Pi.π _ i
        · exact c.π.app WalkingParallelPair.one ≫ Pi.π _ (i, j)
      naturality := by
        intro x y f
        induction x using Opposite.rec' with | h x => ?_
        induction y using Opposite.rec' with | h y => ?_
        have ef : f = f.unop.op := rfl
        revert ef
        generalize f.unop = f'
        rintro rfl
        rcases x with (⟨i⟩ | ⟨⟩) <;> 

Proof state:
case h.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)
y : CategoryTheory.Pairwise ι
a✝¹ a✝ : ι
f' : (op y).unop ⟶ (op (Pairwise.pair a✝¹ a✝)).unop
⊢ ((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 (Pairwise.pair a✝¹ a✝)) ≫
      ((diagram U).op ⋙ F).map f'.op

Next tactic:
rcases y with (⟨⟩ | ⟨j, j⟩)
/-- Implementation of `SheafConditionPairwiseIntersections.coneEquiv`. -/
@[simps]
def coneEquivInverseObj (c : Limits.Cone (SheafConditionEqualizerProducts.diagram F U)) :
    Limits.Cone ((diagram U).op ⋙ F) where
  pt := c.pt
  π :=
    { app := by
        intro x
        induction x using Opposite.rec' with | h x => ?_
        rcases x with (⟨i⟩ | ⟨i, j⟩)
        · exact c.π.app WalkingParallelPair.zero ≫ Pi.π _ i
        · exact c.π.app WalkingParallelPair.one ≫ Pi.π _ (i, j)
      naturality := by
        intro x y f
        induction x using Opposite.rec' with | h x => ?_
        induction y using Opposite.rec' with | h y => ?_
        have ef : f = f.unop.op := rfl
        revert ef
        generalize f.unop = f'
        rintro rfl
        rcases x with (⟨i⟩ | ⟨⟩) <;> rcases y with (⟨⟩ | ⟨j, j⟩) <;> 

Proof state:
case h.h.single.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 a✝ : ι
f' : (op (single a✝)).unop ⟶ (op (single i)).unop
⊢ ((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 (single 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 (single i)) ≫
      ((diagram U).op ⋙ F).map f'.op

Next tactic:
rcases f' with ⟨⟩
/-- Implementation of `SheafConditionPairwiseIntersections.coneEquiv`. -/
@[simps]
def coneEquivInverseObj (c : Limits.Cone (SheafConditionEqualizerProducts.diagram F U)) :
    Limits.Cone ((diagram U).op ⋙ F) where
  pt := c.pt
  π :=
    { app := by
        intro x
        induction x using Opposite.rec' with | h x => ?_
        rcases x with (⟨i⟩ | ⟨i, j⟩)
        · exact c.π.app WalkingParallelPair.zero ≫ Pi.π _ i
        · exact c.π.app WalkingParallelPair.one ≫ Pi.π _ (i, j)
      naturality := by
        intro x y f
        induction x using Opposite.rec' with | h x => ?_
        induction y using Opposite.rec' with | h y => ?_
        have ef : f = f.unop.op := rfl
        revert ef
        generalize f.unop = f'
        rintro rfl
        rcases x with (⟨i⟩ | ⟨⟩) <;> rcases y with (⟨⟩ | ⟨j, j⟩) <;> 

Proof state:
case h.h.single.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✝ j : ι
f' : (op (Pairwise.pair j✝ j)).unop ⟶ (op (single i)).unop
⊢ ((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 (Pairwise.pair j✝ 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 f'.op

Next tactic:
rcases f' with ⟨⟩
/-- Implementation of `SheafConditionPairwiseIntersections.coneEquiv`. -/
@[simps]
def coneEquivInverseObj (c : Limits.Cone (SheafConditionEqualizerProducts.diagram F U)) :
    Limits.Cone ((diagram U).op ⋙ F) where
  pt := c.pt
  π :=
    { app := by
        intro x
        induction x using Opposite.rec' with | h x => ?_
        rcases x with (⟨i⟩ | ⟨i, j⟩)
        · exact c.π.app WalkingParallelPair.zero ≫ Pi.π _ i
        · exact c.π.app WalkingParallelPair.one ≫ Pi.π _ (i, j)
      naturality := by
        intro x y f
        induction x using Opposite.rec' with | h x => ?_
        induction y using Opposite.rec' with | h y => ?_
        have ef : f = f.unop.op := rfl
        revert ef
        generalize f.unop = f'
        rintro rfl
        rcases x with (⟨i⟩ | ⟨⟩) <;> rcases y with (⟨⟩ | ⟨j, j⟩) <;> 

Proof state:
case h.h.pair.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)
a✝² a✝¹ a✝ : ι
f' : (op (single a✝)).unop ⟶ (op (Pairwise.pair a✝² a✝¹)).unop
⊢ ((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 (single 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 f'.op

Next tactic:
rcases f' with ⟨⟩
/-- Implementation of `SheafConditionPairwiseIntersections.coneEquiv`. -/
@[simps]
def coneEquivInverseObj (c : Limits.Cone (SheafConditionEqualizerProducts.diagram F U)) :
    Limits.Cone ((diagram U).op ⋙ F) where
  pt := c.pt
  π :=
    { app := by
        intro x
        induction x using Opposite.rec' with | h x => ?_
        rcases x with (⟨i⟩ | ⟨i, j⟩)
        · exact c.π.app WalkingParallelPair.zero ≫ Pi.π _ i
        · exact c.π.app WalkingParallelPair.one ≫ Pi.π _ (i, j)
      naturality := by
        intro x y f
        induction x using Opposite.rec' with | h x => ?_
        induction y using Opposite.rec' with | h y => ?_
        have ef : f = f.unop.op := rfl
        revert ef
        generalize f.unop = f'
        rintro rfl
        rcases x with (⟨i⟩ | ⟨⟩) <;> rcases y with (⟨⟩ | ⟨j, j⟩) <;> 

Proof state:
case h.h.pair.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✝ j✝ j : ι
f' : (op (Pairwise.pair j✝ j)).unop ⟶ (op (Pairwise.pair a✝¹ a✝)).unop
⊢ ((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 (Pairwise.pair j✝ 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 a✝¹ a✝)) ≫
      ((diagram U).op ⋙ F).map f'.op

Next tactic:
rcases f' with ⟨⟩
/-- Implementation of `SheafConditionPairwiseIntersections.coneEquiv`. -/
@[simps]
def coneEquivInverseObj (c : Limits.Cone (SheafConditionEqualizerProducts.diagram F U)) :
    Limits.Cone ((diagram U).op ⋙ F) where
  pt := c.pt
  π :=
    { app := by
        intro x
        induction x using Opposite.rec' with | h x => ?_
        rcases x with (⟨i⟩ | ⟨i, j⟩)
        · exact c.π.app WalkingParallelPair.zero ≫ Pi.π _ i
        · exact c.π.app WalkingParallelPair.one ≫ Pi.π _ (i, j)
      naturality := by
        intro x y f
        induction x using Opposite.rec' with | h x => ?_
        induction y using Opposite.rec' with | h y => ?_
        have ef : f = f.unop.op := rfl
        revert ef
        generalize f.unop = f'
        rintro rfl
        rcases x with (⟨i⟩ | ⟨⟩) <;> rcases y with (⟨⟩ | ⟨j, j⟩) <;> rcases f' with ⟨⟩
        · 

Proof state:
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 (id_single i).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 (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 (id_single i).op

Next tactic:
dsimp
/-- Implementation of `SheafConditionPairwiseIntersections.coneEquiv`. -/
@[simps]
def coneEquivInverseObj (c : Limits.Cone (SheafConditionEqualizerProducts.diagram F U)) :
    Limits.Cone ((diagram U).op ⋙ F) where
  pt := c.pt
  π :=
    { app := by
        intro x
        induction x using Opposite.rec' with | h x => ?_
        rcases x with (⟨i⟩ | ⟨i, j⟩)
        · exact c.π.app WalkingParallelPair.zero ≫ Pi.π _ i
        · exact c.π.app WalkingParallelPair.one ≫ Pi.π _ (i, j)
      naturality := by
        intro x y f
        induction x using Opposite.rec' with | h x => ?_
        induction y using Opposite.rec' with | h y => ?_
        have ef : f = f.unop.op := rfl
        revert ef
        generalize f.unop = f'
        rintro rfl
        rcases x with (⟨i⟩ | ⟨⟩) <;> rcases y with (⟨⟩ | ⟨j, j⟩) <;> rcases f' with ⟨⟩
        · dsimp
          

Proof state:
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 : ι
⊢ 𝟙 c.pt ≫ Fork.ι c ≫ Pi.π (fun i => F.obj (op (U i))) i =
    (Fork.ι c ≫ Pi.π (fun i => F.obj (op (U i))) i) ≫ F.map ((diagram U).map (id_single i)).op

Next tactic:
erw [F.map_id]
/-- Implementation of `SheafConditionPairwiseIntersections.coneEquiv`. -/
@[simps]
def coneEquivInverseObj (c : Limits.Cone (SheafConditionEqualizerProducts.diagram F U)) :
    Limits.Cone ((diagram U).op ⋙ F) where
  pt := c.pt
  π :=
    { app := by
        intro x
        induction x using Opposite.rec' with | h x => ?_
        rcases x with (⟨i⟩ | ⟨i, j⟩)
        · exact c.π.app WalkingParallelPair.zero ≫ Pi.π _ i
        · exact c.π.app WalkingParallelPair.one ≫ Pi.π _ (i, j)
      naturality := by
        intro x y f
        induction x using Opposite.rec' with | h x => ?_
        induction y using Opposite.rec' with | h y => ?_
        have ef : f = f.unop.op := rfl
        revert ef
        generalize f.unop = f'
        rintro rfl
        rcases x with (⟨i⟩ | ⟨⟩) <;> rcases y with (⟨⟩ | ⟨j, j⟩) <;> rcases f' with ⟨⟩
        · dsimp
          erw [F.map_id]
          

Proof state:
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 : ι
⊢ 𝟙 c.pt ≫ Fork.ι c ≫ Pi.π (fun i => F.obj (op (U i))) i =
    (Fork.ι c ≫ Pi.π (fun i => F.obj (op (U i))) i) ≫ 𝟙 (F.obj (op ((diagram U).obj (single i))))

Next tactic:
simp