[GOAL]
C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝¹ : Category.{max v u, w} D
inst✝ : ConcreteCategory D
Y X : C
P : Cᵒᵖ ⥤ D
S : GrothendieckTopology.Cover J X
x : Meq P S
f : Y ⟶ X
I : GrothendieckTopology.Cover.Relation ((GrothendieckTopology.pullback J f).obj S)
⊢ I.g₁ ≫ I.f₁ ≫ f = I.g₂ ≫ I.f₂ ≫ f
[PROOFSTEP]
simp [I.w_assoc]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝¹ : Category.{max v u, w} D
inst✝ : ConcreteCategory D
X : C
P : Cᵒᵖ ⥤ D
S : GrothendieckTopology.Cover J X
x : (forget D).obj (P.obj (op X))
I : GrothendieckTopology.Cover.Relation S
⊢ ↑(P.map I.g₁.op) ((fun I => ↑(P.map I.f.op) x) (GrothendieckTopology.Cover.Relation.fst I)) =
    ↑(P.map I.g₂.op) ((fun I => ↑(P.map I.f.op) x) (GrothendieckTopology.Cover.Relation.snd I))
[PROOFSTEP]
dsimp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝¹ : Category.{max v u, w} D
inst✝ : ConcreteCategory D
X : C
P : Cᵒᵖ ⥤ D
S : GrothendieckTopology.Cover J X
x : (forget D).obj (P.obj (op X))
I : GrothendieckTopology.Cover.Relation S
⊢ ↑(P.map I.g₁.op) (↑(P.map I.f₁.op) x) = ↑(P.map I.g₂.op) (↑(P.map I.f₂.op) x)
[PROOFSTEP]
simp only [← comp_apply, ← P.map_comp, ← op_comp, I.w]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝³ : Category.{max v u, w} D
inst✝² : ConcreteCategory D
inst✝¹ : PreservesLimits (forget D)
X : C
P : Cᵒᵖ ⥤ D
S : GrothendieckTopology.Cover J X
inst✝ : HasMultiequalizer (GrothendieckTopology.Cover.index S P)
x : Meq P S
I : GrothendieckTopology.Cover.Arrow S
⊢ ↑(Multiequalizer.ι (GrothendieckTopology.Cover.index S P) I) (↑(equiv P S).symm x) = ↑x I
[PROOFSTEP]
rw [← equiv_apply]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝³ : Category.{max v u, w} D
inst✝² : ConcreteCategory D
inst✝¹ : PreservesLimits (forget D)
X : C
P : Cᵒᵖ ⥤ D
S : GrothendieckTopology.Cover J X
inst✝ : HasMultiequalizer (GrothendieckTopology.Cover.index S P)
x : Meq P S
I : GrothendieckTopology.Cover.Arrow S
⊢ ↑(↑(equiv P S) (↑(equiv P S).symm x)) I = ↑x I
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
⊢ ↑((plusObj J P).map f.op) (mk x) = mk (Meq.pullback x f)
[PROOFSTEP]
dsimp [mk, plusObj]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
⊢ ↑(colimMap (diagramPullback J P f) ≫ colimit.pre (diagram J P Y) (pullback J f).op)
      (↑(colimit.ι (diagram J P X) (op S)) (↑(Meq.equiv P S).symm x)) =
    ↑(colimit.ι (diagram J P Y) (op (Cover.pullback S f))) (↑(Meq.equiv P (Cover.pullback S f)).symm (Meq.pullback x f))
[PROOFSTEP]
rw [← comp_apply (x := (Meq.equiv P S).symm x), ι_colimMap_assoc, colimit.ι_pre,
  comp_apply (x := (Meq.equiv P S).symm x)]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
⊢ ↑(colimit.ι (diagram J P Y) ((pullback J f).op.obj (op S)))
      (↑(NatTrans.app (diagramPullback J P f) (op S)) (↑(Meq.equiv P S).symm x)) =
    ↑(colimit.ι (diagram J P Y) (op (Cover.pullback S f))) (↑(Meq.equiv P (Cover.pullback S f)).symm (Meq.pullback x f))
[PROOFSTEP]
apply congr_arg
[GOAL]
case h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
⊢ ↑(NatTrans.app (diagramPullback J P f) (op S)) (↑(Meq.equiv P S).symm x) =
    ↑(Meq.equiv P (Cover.pullback S f)).symm (Meq.pullback x f)
[PROOFSTEP]
apply (Meq.equiv P _).injective
[GOAL]
case h.a
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
⊢ ↑(Meq.equiv P ((pullback J f).op.obj (op S)).unop)
      (↑(NatTrans.app (diagramPullback J P f) (op S)) (↑(Meq.equiv P S).symm x)) =
    ↑(Meq.equiv P ((pullback J f).op.obj (op S)).unop) (↑(Meq.equiv P (Cover.pullback S f)).symm (Meq.pullback x f))
[PROOFSTEP]
erw [Equiv.apply_symm_apply]
[GOAL]
case h.a
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
⊢ ↑(Meq.equiv P ((pullback J f).op.obj (op S)).unop)
      (↑(NatTrans.app (diagramPullback J P f) (op S)) (↑(Meq.equiv P S).symm x)) =
    Meq.pullback x f
[PROOFSTEP]
ext i
[GOAL]
case h.a.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
i : Cover.Arrow ((pullback J f).op.obj (op S)).unop
⊢ ↑(↑(Meq.equiv P ((pullback J f).op.obj (op S)).unop)
          (↑(NatTrans.app (diagramPullback J P f) (op S)) (↑(Meq.equiv P S).symm x)))
      i =
    ↑(Meq.pullback x f) i
[PROOFSTEP]
simp only [Functor.op_obj, unop_op, pullback_obj, diagram_obj, Functor.comp_obj, diagramPullback_app, Meq.equiv_apply,
  Meq.pullback_apply]
[GOAL]
case h.a.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
i : Cover.Arrow ((pullback J f).op.obj (op S)).unop
⊢ ↑(Multiequalizer.ι (Cover.index (Cover.pullback S f) P) i)
      (↑(Multiequalizer.lift (Cover.index ((pullback J f).op.obj (op S)).unop P) ((diagram J P X).obj (op S))
            (fun I => Multiequalizer.ι (Cover.index S P) (Cover.Arrow.base I))
            (_ :
              ∀ (b : (Cover.index ((pullback J f).op.obj (op S)).unop P).R),
                (fun I => Multiequalizer.ι (Cover.index S P) (Cover.Arrow.base I))
                      (MulticospanIndex.fstTo (Cover.index ((pullback J f).op.obj (op S)).unop P) b) ≫
                    MulticospanIndex.fst (Cover.index ((pullback J f).op.obj (op S)).unop P) b =
                  (fun I => Multiequalizer.ι (Cover.index S P) (Cover.Arrow.base I))
                      (MulticospanIndex.sndTo (Cover.index ((pullback J f).op.obj (op S)).unop P) b) ≫
                    MulticospanIndex.snd (Cover.index ((pullback J f).op.obj (op S)).unop P) b))
        (↑(Meq.equiv P S).symm x)) =
    ↑x { Y := i.Y, f := i.f ≫ f, hf := (_ : (Cover.sieve (Cover.pullback S f)).arrows i.f) }
[PROOFSTEP]
erw [← comp_apply, Multiequalizer.lift_ι, Meq.equiv_symm_eq_apply]
[GOAL]
case h.a.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
i : Cover.Arrow ((pullback J f).op.obj (op S)).unop
⊢ ↑x (Cover.Arrow.base i) = ↑x { Y := i.Y, f := i.f ≫ f, hf := (_ : (Cover.sieve (Cover.pullback S f)).arrows i.f) }
[PROOFSTEP]
cases i
[GOAL]
case h.a.h.mk
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
Y✝ : C
f✝ : Y✝ ⟶ Y
hf✝ : (Cover.sieve ((pullback J f).op.obj (op S)).unop).arrows f✝
⊢ ↑x (Cover.Arrow.base { Y := Y✝, f := f✝, hf := hf✝ }) =
    ↑x
      { Y := { Y := Y✝, f := f✝, hf := hf✝ }.Y, f := { Y := Y✝, f := f✝, hf := hf✝ }.f ≫ f,
        hf := (_ : (Cover.sieve (Cover.pullback S f)).arrows { Y := Y✝, f := f✝, hf := hf✝ }.f) }
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : (forget D).obj (P.obj (op X))
⊢ ↑(NatTrans.app (toPlus J P) (op X)) x = mk (Meq.mk S x)
[PROOFSTEP]
dsimp [mk, toPlus]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : (forget D).obj (P.obj (op X))
⊢ ↑(Cover.toMultiequalizer ⊤ P ≫ colimit.ι (diagram J P X) (op ⊤)) x =
    ↑(colimit.ι (diagram J P X) (op S)) (↑(Meq.equiv P S).symm (Meq.mk S x))
[PROOFSTEP]
let e : S ⟶ ⊤ := homOfLE (OrderTop.le_top _)
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : (forget D).obj (P.obj (op X))
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
⊢ ↑(Cover.toMultiequalizer ⊤ P ≫ colimit.ι (diagram J P X) (op ⊤)) x =
    ↑(colimit.ι (diagram J P X) (op S)) (↑(Meq.equiv P S).symm (Meq.mk S x))
[PROOFSTEP]
rw [← colimit.w _ e.op]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : (forget D).obj (P.obj (op X))
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
⊢ ↑(Cover.toMultiequalizer ⊤ P ≫ (diagram J P X).map e.op ≫ colimit.ι (diagram J P X) (op S)) x =
    ↑(colimit.ι (diagram J P X) (op S)) (↑(Meq.equiv P S).symm (Meq.mk S x))
[PROOFSTEP]
delta Cover.toMultiequalizer
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : (forget D).obj (P.obj (op X))
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
⊢ ↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op X)) (fun I => P.map I.f.op)
            (_ :
              ∀ (I : (Cover.index ⊤ P).R),
                (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I =
                  (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I) ≫
          (diagram J P X).map e.op ≫ colimit.ι (diagram J P X) (op S))
      x =
    ↑(colimit.ι (diagram J P X) (op S)) (↑(Meq.equiv P S).symm (Meq.mk S x))
[PROOFSTEP]
erw [comp_apply, comp_apply]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : (forget D).obj (P.obj (op X))
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
⊢ ↑(colimit.ι (diagram J P X) (op S))
      (↑((diagram J P X).map e.op)
        (↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op X)) (fun I => P.map I.f.op)
              (_ :
                ∀ (I : (Cover.index ⊤ P).R),
                  (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                      MulticospanIndex.fst (Cover.index ⊤ P) I =
                    (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                      MulticospanIndex.snd (Cover.index ⊤ P) I))
          x)) =
    ↑(colimit.ι (diagram J P X) (op S)) (↑(Meq.equiv P S).symm (Meq.mk S x))
[PROOFSTEP]
apply congr_arg
[GOAL]
case h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : (forget D).obj (P.obj (op X))
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
⊢ ↑((diagram J P X).map e.op)
      (↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op X)) (fun I => P.map I.f.op)
            (_ :
              ∀ (I : (Cover.index ⊤ P).R),
                (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I =
                  (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I))
        x) =
    ↑(Meq.equiv P S).symm (Meq.mk S x)
[PROOFSTEP]
dsimp [diagram]
[GOAL]
case h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : (forget D).obj (P.obj (op X))
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
⊢ ↑(Multiequalizer.lift (Cover.index S P) (multiequalizer (Cover.index ⊤ P))
          (fun I => Multiequalizer.ι (Cover.index ⊤ P) (Cover.Arrow.map I (homOfLE (_ : S ≤ ⊤))))
          (_ :
            ∀ (I : (Cover.index (op S).unop P).R),
              Multiequalizer.ι (Cover.index (op ⊤).unop P)
                    (MulticospanIndex.fstTo (Cover.index (op ⊤).unop P)
                      (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)) ≫
                  MulticospanIndex.fst (Cover.index (op ⊤).unop P)
                    (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop) =
                Multiequalizer.ι (Cover.index (op ⊤).unop P)
                    (MulticospanIndex.sndTo (Cover.index (op ⊤).unop P)
                      (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)) ≫
                  MulticospanIndex.snd (Cover.index (op ⊤).unop P)
                    (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)))
      (↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op X)) (fun I => P.map I.f.op)
            (_ :
              ∀ (I : (Cover.index ⊤ P).R),
                (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I =
                  (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I))
        x) =
    ↑(Meq.equiv P S).symm (Meq.mk S x)
[PROOFSTEP]
apply Concrete.multiequalizer_ext
[GOAL]
case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : (forget D).obj (P.obj (op X))
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
⊢ ∀ (t : (Cover.index S P).L),
    ↑(Multiequalizer.ι (Cover.index S P) t)
        (↑(Multiequalizer.lift (Cover.index S P) (multiequalizer (Cover.index ⊤ P))
              (fun I => Multiequalizer.ι (Cover.index ⊤ P) (Cover.Arrow.map I (homOfLE (_ : S ≤ ⊤))))
              (_ :
                ∀ (I : (Cover.index (op S).unop P).R),
                  Multiequalizer.ι (Cover.index (op ⊤).unop P)
                        (MulticospanIndex.fstTo (Cover.index (op ⊤).unop P)
                          (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)) ≫
                      MulticospanIndex.fst (Cover.index (op ⊤).unop P)
                        (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop) =
                    Multiequalizer.ι (Cover.index (op ⊤).unop P)
                        (MulticospanIndex.sndTo (Cover.index (op ⊤).unop P)
                          (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)) ≫
                      MulticospanIndex.snd (Cover.index (op ⊤).unop P)
                        (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)))
          (↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op X)) (fun I => P.map I.f.op)
                (_ :
                  ∀ (I : (Cover.index ⊤ P).R),
                    (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                        MulticospanIndex.fst (Cover.index ⊤ P) I =
                      (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                        MulticospanIndex.snd (Cover.index ⊤ P) I))
            x)) =
      ↑(Multiequalizer.ι (Cover.index S P) t) (↑(Meq.equiv P S).symm (Meq.mk S x))
[PROOFSTEP]
intro i
[GOAL]
case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : (forget D).obj (P.obj (op X))
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
i : (Cover.index S P).L
⊢ ↑(Multiequalizer.ι (Cover.index S P) i)
      (↑(Multiequalizer.lift (Cover.index S P) (multiequalizer (Cover.index ⊤ P))
            (fun I => Multiequalizer.ι (Cover.index ⊤ P) (Cover.Arrow.map I (homOfLE (_ : S ≤ ⊤))))
            (_ :
              ∀ (I : (Cover.index (op S).unop P).R),
                Multiequalizer.ι (Cover.index (op ⊤).unop P)
                      (MulticospanIndex.fstTo (Cover.index (op ⊤).unop P)
                        (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)) ≫
                    MulticospanIndex.fst (Cover.index (op ⊤).unop P)
                      (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop) =
                  Multiequalizer.ι (Cover.index (op ⊤).unop P)
                      (MulticospanIndex.sndTo (Cover.index (op ⊤).unop P)
                        (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)) ≫
                    MulticospanIndex.snd (Cover.index (op ⊤).unop P)
                      (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)))
        (↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op X)) (fun I => P.map I.f.op)
              (_ :
                ∀ (I : (Cover.index ⊤ P).R),
                  (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                      MulticospanIndex.fst (Cover.index ⊤ P) I =
                    (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                      MulticospanIndex.snd (Cover.index ⊤ P) I))
          x)) =
    ↑(Multiequalizer.ι (Cover.index S P) i) (↑(Meq.equiv P S).symm (Meq.mk S x))
[PROOFSTEP]
simp only [← comp_apply, Category.assoc, Multiequalizer.lift_ι, Category.comp_id, Meq.equiv_symm_eq_apply]
[GOAL]
case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : (forget D).obj (P.obj (op X))
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
i : (Cover.index S P).L
⊢ ↑(P.map (Cover.Arrow.map i (homOfLE (_ : S ≤ ⊤))).f.op) x = ↑(Meq.mk S x) i
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
⊢ ↑(NatTrans.app (toPlus J P) (op I.Y)) (↑x I) = ↑((plusObj J P).map I.f.op) (mk x)
[PROOFSTEP]
dsimp only [toPlus, plusObj]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
⊢ ↑(Cover.toMultiequalizer ⊤ P ≫ colimit.ι (diagram J P (op I.Y).unop) (op ⊤)) (↑x I) =
    ↑(colimMap (diagramPullback J P I.f.op.unop) ≫ colimit.pre (diagram J P (op I.Y).unop) (pullback J I.f.op.unop).op)
      (mk x)
[PROOFSTEP]
delta Cover.toMultiequalizer
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
⊢ ↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op (op I.Y).unop)) (fun I_1 => P.map I_1.f.op)
            (_ :
              ∀ (I_1 : (Cover.index ⊤ P).R),
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                  (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I_1) ≫
          colimit.ι (diagram J P (op I.Y).unop) (op ⊤))
      (↑x I) =
    ↑(colimMap (diagramPullback J P I.f.op.unop) ≫ colimit.pre (diagram J P (op I.Y).unop) (pullback J I.f.op.unop).op)
      (mk x)
[PROOFSTEP]
dsimp [mk]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
⊢ ↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op I.Y)) (fun I_1 => P.map I_1.f.op)
            (_ :
              ∀ (I_1 : (Cover.index ⊤ P).R),
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                  (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I_1) ≫
          colimit.ι (diagram J P I.Y) (op ⊤))
      (↑x I) =
    ↑(colimMap (diagramPullback J P I.f) ≫ colimit.pre (diagram J P I.Y) (pullback J I.f).op)
      (↑(colimit.ι (diagram J P X) (op S)) (↑(Meq.equiv P S).symm x))
[PROOFSTEP]
erw [← comp_apply]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
⊢ ↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op I.Y)) (fun I_1 => P.map I_1.f.op)
            (_ :
              ∀ (I_1 : (Cover.index ⊤ P).R),
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                  (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I_1) ≫
          colimit.ι (diagram J P I.Y) (op ⊤))
      (↑x I) =
    ↑(colimit.ι (diagram J P X) (op S) ≫
          colimMap (diagramPullback J P I.f) ≫ colimit.pre (diagram J P I.Y) (pullback J I.f).op)
      (↑(Meq.equiv P S).symm x)
[PROOFSTEP]
rw [ι_colimMap_assoc, colimit.ι_pre, comp_apply, comp_apply]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
⊢ ↑(colimit.ι (diagram J P I.Y) (op ⊤))
      (↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op I.Y)) (fun I_1 => P.map I_1.f.op)
            (_ :
              ∀ (I_1 : (Cover.index ⊤ P).R),
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                  (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I_1))
        (↑x I)) =
    ↑(colimit.ι (diagram J P I.Y) ((pullback J I.f).op.obj (op S)))
      (↑(NatTrans.app (diagramPullback J P I.f) (op S)) (↑(Meq.equiv P S).symm x))
[PROOFSTEP]
dsimp only [Functor.op]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
⊢ ↑(colimit.ι (diagram J P I.Y) (op ⊤))
      (↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op I.Y)) (fun I_1 => P.map I_1.f.op)
            (_ :
              ∀ (I_1 : (Cover.index ⊤ P).R),
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                  (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I_1))
        (↑x I)) =
    ↑(colimit.ι (diagram J P I.Y) (op ((pullback J I.f).obj (op S).unop)))
      (↑(NatTrans.app (diagramPullback J P I.f) (op S)) (↑(Meq.equiv P S).symm x))
[PROOFSTEP]
let e : (J.pullback I.f).obj (unop (op S)) ⟶ ⊤ := homOfLE (OrderTop.le_top _)
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj (op S).unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj (op S).unop ≤ ⊤)
⊢ ↑(colimit.ι (diagram J P I.Y) (op ⊤))
      (↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op I.Y)) (fun I_1 => P.map I_1.f.op)
            (_ :
              ∀ (I_1 : (Cover.index ⊤ P).R),
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                  (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I_1))
        (↑x I)) =
    ↑(colimit.ι (diagram J P I.Y) (op ((pullback J I.f).obj (op S).unop)))
      (↑(NatTrans.app (diagramPullback J P I.f) (op S)) (↑(Meq.equiv P S).symm x))
[PROOFSTEP]
rw [← colimit.w _ e.op]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj (op S).unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj (op S).unop ≤ ⊤)
⊢ ↑((diagram J P I.Y).map e.op ≫ colimit.ι (diagram J P I.Y) (op ((pullback J I.f).obj (op S).unop)))
      (↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op I.Y)) (fun I_1 => P.map I_1.f.op)
            (_ :
              ∀ (I_1 : (Cover.index ⊤ P).R),
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                  (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I_1))
        (↑x I)) =
    ↑(colimit.ι (diagram J P I.Y) (op ((pullback J I.f).obj (op S).unop)))
      (↑(NatTrans.app (diagramPullback J P I.f) (op S)) (↑(Meq.equiv P S).symm x))
[PROOFSTEP]
erw [comp_apply]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj (op S).unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj (op S).unop ≤ ⊤)
⊢ ↑(colimit.ι (diagram J P I.Y) (op ((pullback J I.f).obj (op S).unop)))
      (↑((diagram J P I.Y).map e.op)
        (↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op I.Y)) (fun I_1 => P.map I_1.f.op)
              (_ :
                ∀ (I_1 : (Cover.index ⊤ P).R),
                  (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                      MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                    (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                      MulticospanIndex.snd (Cover.index ⊤ P) I_1))
          (↑x I))) =
    ↑(colimit.ι (diagram J P I.Y) (op ((pullback J I.f).obj (op S).unop)))
      (↑(NatTrans.app (diagramPullback J P I.f) (op S)) (↑(Meq.equiv P S).symm x))
[PROOFSTEP]
apply congr_arg
[GOAL]
case h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj (op S).unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj (op S).unop ≤ ⊤)
⊢ ↑((diagram J P I.Y).map e.op)
      (↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op I.Y)) (fun I_1 => P.map I_1.f.op)
            (_ :
              ∀ (I_1 : (Cover.index ⊤ P).R),
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                  (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I_1))
        (↑x I)) =
    ↑(NatTrans.app (diagramPullback J P I.f) (op S)) (↑(Meq.equiv P S).symm x)
[PROOFSTEP]
apply Concrete.multiequalizer_ext
[GOAL]
case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj (op S).unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj (op S).unop ≤ ⊤)
⊢ ∀ (t : (Cover.index (op ((pullback J I.f).obj (op S).unop)).unop P).L),
    ↑(Multiequalizer.ι (Cover.index (op ((pullback J I.f).obj (op S).unop)).unop P) t)
        (↑((diagram J P I.Y).map e.op)
          (↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op I.Y)) (fun I_1 => P.map I_1.f.op)
                (_ :
                  ∀ (I_1 : (Cover.index ⊤ P).R),
                    (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                        MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                      (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                        MulticospanIndex.snd (Cover.index ⊤ P) I_1))
            (↑x I))) =
      ↑(Multiequalizer.ι (Cover.index (op ((pullback J I.f).obj (op S).unop)).unop P) t)
        (↑(NatTrans.app (diagramPullback J P I.f) (op S)) (↑(Meq.equiv P S).symm x))
[PROOFSTEP]
intro i
[GOAL]
case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj (op S).unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj (op S).unop ≤ ⊤)
i : (Cover.index (op ((pullback J I.f).obj (op S).unop)).unop P).L
⊢ ↑(Multiequalizer.ι (Cover.index (op ((pullback J I.f).obj (op S).unop)).unop P) i)
      (↑((diagram J P I.Y).map e.op)
        (↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op I.Y)) (fun I_1 => P.map I_1.f.op)
              (_ :
                ∀ (I_1 : (Cover.index ⊤ P).R),
                  (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                      MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                    (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                      MulticospanIndex.snd (Cover.index ⊤ P) I_1))
          (↑x I))) =
    ↑(Multiequalizer.ι (Cover.index (op ((pullback J I.f).obj (op S).unop)).unop P) i)
      (↑(NatTrans.app (diagramPullback J P I.f) (op S)) (↑(Meq.equiv P S).symm x))
[PROOFSTEP]
dsimp [diagram]
[GOAL]
case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj (op S).unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj (op S).unop ≤ ⊤)
i : (Cover.index (op ((pullback J I.f).obj (op S).unop)).unop P).L
⊢ ↑(Multiequalizer.ι (Cover.index (Cover.pullback S I.f) P) i)
      (↑(Multiequalizer.lift (Cover.index (Cover.pullback S I.f) P) (multiequalizer (Cover.index ⊤ P))
            (fun I_1 =>
              Multiequalizer.ι (Cover.index ⊤ P) (Cover.Arrow.map I_1 (homOfLE (_ : Cover.pullback S I.f ≤ ⊤))))
            (_ :
              ∀ (I_1 : (Cover.index (op (Cover.pullback S I.f)).unop P).R),
                Multiequalizer.ι (Cover.index (op ⊤).unop P)
                      (MulticospanIndex.fstTo (Cover.index (op ⊤).unop P)
                        (Cover.Relation.map I_1 (homOfLE (_ : Cover.pullback S I.f ≤ ⊤)).op.unop)) ≫
                    MulticospanIndex.fst (Cover.index (op ⊤).unop P)
                      (Cover.Relation.map I_1 (homOfLE (_ : Cover.pullback S I.f ≤ ⊤)).op.unop) =
                  Multiequalizer.ι (Cover.index (op ⊤).unop P)
                      (MulticospanIndex.sndTo (Cover.index (op ⊤).unop P)
                        (Cover.Relation.map I_1 (homOfLE (_ : Cover.pullback S I.f ≤ ⊤)).op.unop)) ≫
                    MulticospanIndex.snd (Cover.index (op ⊤).unop P)
                      (Cover.Relation.map I_1 (homOfLE (_ : Cover.pullback S I.f ≤ ⊤)).op.unop)))
        (↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op I.Y)) (fun I_1 => P.map I_1.f.op)
              (_ :
                ∀ (I_1 : (Cover.index ⊤ P).R),
                  (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                      MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                    (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                      MulticospanIndex.snd (Cover.index ⊤ P) I_1))
          (↑x I))) =
    ↑(Multiequalizer.ι (Cover.index (Cover.pullback S I.f) P) i)
      (↑(Multiequalizer.lift (Cover.index (Cover.pullback S I.f) P) (multiequalizer (Cover.index S P))
            (fun I_1 => Multiequalizer.ι (Cover.index S P) (Cover.Arrow.base I_1))
            (_ :
              ∀ (I_1 : (Cover.index ((pullback J I.f).op.obj (op S)).unop P).R),
                Multiequalizer.ι (Cover.index (op S).unop P)
                      (MulticospanIndex.fstTo (Cover.index (op S).unop P) (Cover.Relation.base I_1)) ≫
                    MulticospanIndex.fst (Cover.index (op S).unop P) (Cover.Relation.base I_1) =
                  Multiequalizer.ι (Cover.index (op S).unop P)
                      (MulticospanIndex.sndTo (Cover.index (op S).unop P) (Cover.Relation.base I_1)) ≫
                    MulticospanIndex.snd (Cover.index (op S).unop P) (Cover.Relation.base I_1)))
        (↑(Meq.equiv P S).symm x))
[PROOFSTEP]
rw [← comp_apply, ← comp_apply, ← comp_apply, Multiequalizer.lift_ι, Multiequalizer.lift_ι, Multiequalizer.lift_ι]
[GOAL]
case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj (op S).unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj (op S).unop ≤ ⊤)
i : (Cover.index (op ((pullback J I.f).obj (op S).unop)).unop P).L
⊢ ↑(P.map (Cover.Arrow.map i (homOfLE (_ : Cover.pullback S I.f ≤ ⊤))).f.op) (↑x I) =
    ↑(Multiequalizer.ι (Cover.index S P) (Cover.Arrow.base i)) (↑(Meq.equiv P S).symm x)
[PROOFSTEP]
erw [Meq.equiv_symm_eq_apply]
[GOAL]
case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj (op S).unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj (op S).unop ≤ ⊤)
i : (Cover.index (op ((pullback J I.f).obj (op S).unop)).unop P).L
⊢ ↑(P.map (Cover.Arrow.map i (homOfLE (_ : Cover.pullback S I.f ≤ ⊤))).f.op) (↑x I) = ↑x (Cover.Arrow.base i)
[PROOFSTEP]
let RR : S.Relation := ⟨_, _, _, i.f, 𝟙 _, I.f, i.f ≫ I.f, I.hf, Sieve.downward_closed _ I.hf _, by simp⟩
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj (op S).unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj (op S).unop ≤ ⊤)
i : (Cover.index (op ((pullback J I.f).obj (op S).unop)).unop P).L
⊢ i.f ≫ I.f = 𝟙 i.Y ≫ i.f ≫ I.f
[PROOFSTEP]
simp
[GOAL]
case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj (op S).unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj (op S).unop ≤ ⊤)
i : (Cover.index (op ((pullback J I.f).obj (op S).unop)).unop P).L
RR : Cover.Relation S :=
  { Y₁ := I.Y, Y₂ := i.Y, Z := i.Y, g₁ := i.f, g₂ := 𝟙 i.Y, f₁ := I.f, f₂ := i.f ≫ I.f,
    h₁ := (_ : (Cover.sieve S).arrows I.f), h₂ := (_ : (Cover.sieve S).arrows (i.f ≫ I.f)),
    w := (_ : i.f ≫ I.f = 𝟙 i.Y ≫ i.f ≫ I.f) }
⊢ ↑(P.map (Cover.Arrow.map i (homOfLE (_ : Cover.pullback S I.f ≤ ⊤))).f.op) (↑x I) = ↑x (Cover.Arrow.base i)
[PROOFSTEP]
erw [x.condition RR]
[GOAL]
case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj (op S).unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj (op S).unop ≤ ⊤)
i : (Cover.index (op ((pullback J I.f).obj (op S).unop)).unop P).L
RR : Cover.Relation S :=
  { Y₁ := I.Y, Y₂ := i.Y, Z := i.Y, g₁ := i.f, g₂ := 𝟙 i.Y, f₁ := I.f, f₂ := i.f ≫ I.f,
    h₁ := (_ : (Cover.sieve S).arrows I.f), h₂ := (_ : (Cover.sieve S).arrows (i.f ≫ I.f)),
    w := (_ : i.f ≫ I.f = 𝟙 i.Y ≫ i.f ≫ I.f) }
⊢ ↑(P.map RR.g₂.op) (↑x (MulticospanIndex.sndTo (Cover.index S P) RR)) = ↑x (Cover.Arrow.base i)
[PROOFSTEP]
simp only [unop_op, pullback_obj, op_id, Functor.map_id, id_apply]
[GOAL]
case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj (op S).unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj (op S).unop ≤ ⊤)
i : (Cover.index (op ((pullback J I.f).obj (op S).unop)).unop P).L
RR : Cover.Relation S :=
  { Y₁ := I.Y, Y₂ := i.Y, Z := i.Y, g₁ := i.f, g₂ := 𝟙 i.Y, f₁ := I.f, f₂ := i.f ≫ I.f,
    h₁ := (_ : (Cover.sieve S).arrows I.f), h₂ := (_ : (Cover.sieve S).arrows (i.f ≫ I.f)),
    w := (_ : i.f ≫ I.f = 𝟙 i.Y ≫ i.f ≫ I.f) }
⊢ ↑x
      (MulticospanIndex.sndTo (Cover.index S P)
        { Y₁ := I.Y, Y₂ := i.Y, Z := i.Y, g₁ := i.f, g₂ := 𝟙 i.Y, f₁ := I.f, f₂ := i.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S).arrows I.f), h₂ := (_ : (Cover.sieve S).arrows (i.f ≫ I.f)),
          w := (_ : i.f ≫ I.f = 𝟙 i.Y ≫ i.f ≫ I.f) }) =
    ↑x (Cover.Arrow.base i)
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
x : (forget D).obj (P.obj (op X))
⊢ ↑(NatTrans.app (toPlus J P) (op X)) x = mk (Meq.mk ⊤ x)
[PROOFSTEP]
dsimp [mk, toPlus]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
x : (forget D).obj (P.obj (op X))
⊢ ↑(Cover.toMultiequalizer ⊤ P ≫ colimit.ι (diagram J P X) (op ⊤)) x =
    ↑(colimit.ι (diagram J P X) (op ⊤)) (↑(Meq.equiv P ⊤).symm (Meq.mk ⊤ x))
[PROOFSTEP]
delta Cover.toMultiequalizer
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
x : (forget D).obj (P.obj (op X))
⊢ ↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op X)) (fun I => P.map I.f.op)
            (_ :
              ∀ (I : (Cover.index ⊤ P).R),
                (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I =
                  (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I) ≫
          colimit.ι (diagram J P X) (op ⊤))
      x =
    ↑(colimit.ι (diagram J P X) (op ⊤)) (↑(Meq.equiv P ⊤).symm (Meq.mk ⊤ x))
[PROOFSTEP]
simp only [comp_apply]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
x : (forget D).obj (P.obj (op X))
⊢ ↑(colimit.ι (diagram J P X) (op ⊤))
      (↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op X)) (fun I => P.map I.f.op)
            (_ :
              ∀ (I : (Cover.index ⊤ P).R),
                (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I =
                  (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I))
        x) =
    ↑(colimit.ι (diagram J P X) (op ⊤)) (↑(Meq.equiv P ⊤).symm (Meq.mk ⊤ x))
[PROOFSTEP]
apply congr_arg
[GOAL]
case h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
x : (forget D).obj (P.obj (op X))
⊢ ↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op X)) (fun I => P.map I.f.op)
          (_ :
            ∀ (I : (Cover.index ⊤ P).R),
              (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                  MulticospanIndex.fst (Cover.index ⊤ P) I =
                (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                  MulticospanIndex.snd (Cover.index ⊤ P) I))
      x =
    ↑(Meq.equiv P ⊤).symm (Meq.mk ⊤ x)
[PROOFSTEP]
apply (Meq.equiv P ⊤).injective
[GOAL]
case h.a
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
x : (forget D).obj (P.obj (op X))
⊢ ↑(Meq.equiv P ⊤)
      (↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op X)) (fun I => P.map I.f.op)
            (_ :
              ∀ (I : (Cover.index ⊤ P).R),
                (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I =
                  (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I))
        x) =
    ↑(Meq.equiv P ⊤) (↑(Meq.equiv P ⊤).symm (Meq.mk ⊤ x))
[PROOFSTEP]
ext i
[GOAL]
case h.a.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
x : (forget D).obj (P.obj (op X))
i : Cover.Arrow ⊤
⊢ ↑(↑(Meq.equiv P ⊤)
          (↑(Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op X)) (fun I => P.map I.f.op)
                (_ :
                  ∀ (I : (Cover.index ⊤ P).R),
                    (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                        MulticospanIndex.fst (Cover.index ⊤ P) I =
                      (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                        MulticospanIndex.snd (Cover.index ⊤ P) I))
            x))
      i =
    ↑(↑(Meq.equiv P ⊤) (↑(Meq.equiv P ⊤).symm (Meq.mk ⊤ x))) i
[PROOFSTEP]
rw [Meq.equiv_apply, Equiv.apply_symm_apply, ← comp_apply, Multiequalizer.lift_ι]
[GOAL]
case h.a.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
x : (forget D).obj (P.obj (op X))
i : Cover.Arrow ⊤
⊢ ↑(P.map i.f.op) x = ↑(Meq.mk ⊤ x) i
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
x : (forget D).obj ((plusObj J P).obj (op X))
⊢ ∃ S y, x = mk y
[PROOFSTEP]
obtain ⟨S, y, h⟩ := Concrete.colimit_exists_rep (J.diagram P X) x
[GOAL]
case intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
x : (forget D).obj ((plusObj J P).obj (op X))
S : (Cover J X)ᵒᵖ
y : (forget D).obj ((diagram J P X).obj S)
h : ↑(colimit.ι (diagram J P X) S) y = x
⊢ ∃ S y, x = mk y
[PROOFSTEP]
use S.unop, Meq.equiv _ _ y
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
x : (forget D).obj ((plusObj J P).obj (op X))
S : (Cover J X)ᵒᵖ
y : (forget D).obj ((diagram J P X).obj S)
h : ↑(colimit.ι (diagram J P X) S) y = x
⊢ x = mk (↑(Meq.equiv P S.unop) y)
[PROOFSTEP]
rw [← h]
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
x : (forget D).obj ((plusObj J P).obj (op X))
S : (Cover J X)ᵒᵖ
y : (forget D).obj ((diagram J P X).obj S)
h : ↑(colimit.ι (diagram J P X) S) y = x
⊢ ↑(colimit.ι (diagram J P X) S) y = mk (↑(Meq.equiv P S.unop) y)
[PROOFSTEP]
dsimp [mk]
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
x : (forget D).obj ((plusObj J P).obj (op X))
S : (Cover J X)ᵒᵖ
y : (forget D).obj ((diagram J P X).obj S)
h : ↑(colimit.ι (diagram J P X) S) y = x
⊢ ↑(colimit.ι (diagram J P X) S) y =
    ↑(colimit.ι (diagram J P X) S) (↑(Meq.equiv P S.unop).symm (↑(Meq.equiv P S.unop) y))
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
⊢ mk x = mk y ↔ ∃ W h1 h2, Meq.refine x h1 = Meq.refine y h2
[PROOFSTEP]
constructor
[GOAL]
case mp
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
⊢ mk x = mk y → ∃ W h1 h2, Meq.refine x h1 = Meq.refine y h2
[PROOFSTEP]
intro h
[GOAL]
case mp
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
h : mk x = mk y
⊢ ∃ W h1 h2, Meq.refine x h1 = Meq.refine y h2
[PROOFSTEP]
obtain ⟨W, h1, h2, hh⟩ := Concrete.colimit_exists_of_rep_eq _ _ _ h
[GOAL]
case mp.intro.intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (Cover J X)ᵒᵖ
h1 : op S ⟶ W
h2 : op T ⟶ W
hh : ↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x) = ↑((diagram J P X).map h2) (↑(Meq.equiv P T).symm y)
⊢ ∃ W h1 h2, Meq.refine x h1 = Meq.refine y h2
[PROOFSTEP]
use W.unop, h1.unop, h2.unop
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (Cover J X)ᵒᵖ
h1 : op S ⟶ W
h2 : op T ⟶ W
hh : ↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x) = ↑((diagram J P X).map h2) (↑(Meq.equiv P T).symm y)
⊢ Meq.refine x h1.unop = Meq.refine y h2.unop
[PROOFSTEP]
ext I
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (Cover J X)ᵒᵖ
h1 : op S ⟶ W
h2 : op T ⟶ W
hh : ↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x) = ↑((diagram J P X).map h2) (↑(Meq.equiv P T).symm y)
I : Cover.Arrow W.unop
⊢ ↑(Meq.refine x h1.unop) I = ↑(Meq.refine y h2.unop) I
[PROOFSTEP]
apply_fun Multiequalizer.ι (W.unop.index P) I at hh 
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (Cover J X)ᵒᵖ
h1 : op S ⟶ W
h2 : op T ⟶ W
I : Cover.Arrow W.unop
hh :
  ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x)) =
    ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h2) (↑(Meq.equiv P T).symm y))
⊢ ↑(Meq.refine x h1.unop) I = ↑(Meq.refine y h2.unop) I
[PROOFSTEP]
convert hh
[GOAL]
case h.e'_2.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (Cover J X)ᵒᵖ
h1 : op S ⟶ W
h2 : op T ⟶ W
I : Cover.Arrow W.unop
hh :
  ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x)) =
    ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h2) (↑(Meq.equiv P T).symm y))
e_1✝ :
  (forget D).obj (P.obj (op I.Y)) =
    (fun x => (forget D).obj (MulticospanIndex.left (Cover.index W.unop P) I))
      (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x))
⊢ ↑(Meq.refine x h1.unop) I =
    ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x))
case h.e'_3.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (Cover J X)ᵒᵖ
h1 : op S ⟶ W
h2 : op T ⟶ W
I : Cover.Arrow W.unop
hh :
  ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x)) =
    ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h2) (↑(Meq.equiv P T).symm y))
e_1✝ :
  (forget D).obj (P.obj (op I.Y)) =
    (fun x => (forget D).obj (MulticospanIndex.left (Cover.index W.unop P) I))
      (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x))
⊢ ↑(Meq.refine y h2.unop) I =
    ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h2) (↑(Meq.equiv P T).symm y))
[PROOFSTEP]
all_goals
  dsimp [diagram]
  erw [← comp_apply, Multiequalizer.lift_ι, Meq.equiv_symm_eq_apply]
  cases I; rfl
[GOAL]
case h.e'_2.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (Cover J X)ᵒᵖ
h1 : op S ⟶ W
h2 : op T ⟶ W
I : Cover.Arrow W.unop
hh :
  ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x)) =
    ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h2) (↑(Meq.equiv P T).symm y))
e_1✝ :
  (forget D).obj (P.obj (op I.Y)) =
    (fun x => (forget D).obj (MulticospanIndex.left (Cover.index W.unop P) I))
      (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x))
⊢ ↑(Meq.refine x h1.unop) I =
    ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x))
[PROOFSTEP]
dsimp [diagram]
[GOAL]
case h.e'_2.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (Cover J X)ᵒᵖ
h1 : op S ⟶ W
h2 : op T ⟶ W
I : Cover.Arrow W.unop
hh :
  ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x)) =
    ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h2) (↑(Meq.equiv P T).symm y))
e_1✝ :
  (forget D).obj (P.obj (op I.Y)) =
    (fun x => (forget D).obj (MulticospanIndex.left (Cover.index W.unop P) I))
      (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x))
⊢ ↑x { Y := I.Y, f := I.f, hf := (_ : ((fun a => ↑a) S).arrows I.f) } =
    ↑(Multiequalizer.ι (Cover.index W.unop P) I)
      (↑(Multiequalizer.lift (Cover.index W.unop P) (multiequalizer (Cover.index S P))
            (fun I => Multiequalizer.ι (Cover.index S P) (Cover.Arrow.map I h1.unop))
            (_ :
              ∀ (I : (Cover.index W.unop P).R),
                Multiequalizer.ι (Cover.index (op S).unop P)
                      (MulticospanIndex.fstTo (Cover.index (op S).unop P) (Cover.Relation.map I h1.unop)) ≫
                    MulticospanIndex.fst (Cover.index (op S).unop P) (Cover.Relation.map I h1.unop) =
                  Multiequalizer.ι (Cover.index (op S).unop P)
                      (MulticospanIndex.sndTo (Cover.index (op S).unop P) (Cover.Relation.map I h1.unop)) ≫
                    MulticospanIndex.snd (Cover.index (op S).unop P) (Cover.Relation.map I h1.unop)))
        (↑(Meq.equiv P S).symm x))
[PROOFSTEP]
erw [← comp_apply, Multiequalizer.lift_ι, Meq.equiv_symm_eq_apply]
[GOAL]
case h.e'_2.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (Cover J X)ᵒᵖ
h1 : op S ⟶ W
h2 : op T ⟶ W
I : Cover.Arrow W.unop
hh :
  ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x)) =
    ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h2) (↑(Meq.equiv P T).symm y))
e_1✝ :
  (forget D).obj (P.obj (op I.Y)) =
    (fun x => (forget D).obj (MulticospanIndex.left (Cover.index W.unop P) I))
      (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x))
⊢ ↑x { Y := I.Y, f := I.f, hf := (_ : ((fun a => ↑a) S).arrows I.f) } = ↑x (Cover.Arrow.map I h1.unop)
[PROOFSTEP]
cases I
[GOAL]
case h.e'_2.h.mk
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (Cover J X)ᵒᵖ
h1 : op S ⟶ W
h2 : op T ⟶ W
Y✝ : C
f✝ : Y✝ ⟶ X
hf✝ : (Cover.sieve W.unop).arrows f✝
hh :
  ↑(Multiequalizer.ι (Cover.index W.unop P) { Y := Y✝, f := f✝, hf := hf✝ })
      (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x)) =
    ↑(Multiequalizer.ι (Cover.index W.unop P) { Y := Y✝, f := f✝, hf := hf✝ })
      (↑((diagram J P X).map h2) (↑(Meq.equiv P T).symm y))
e_1✝ :
  (forget D).obj (P.obj (op { Y := Y✝, f := f✝, hf := hf✝ }.Y)) =
    (fun x => (forget D).obj (MulticospanIndex.left (Cover.index W.unop P) { Y := Y✝, f := f✝, hf := hf✝ }))
      (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x))
⊢ ↑x
      { Y := { Y := Y✝, f := f✝, hf := hf✝ }.Y, f := { Y := Y✝, f := f✝, hf := hf✝ }.f,
        hf := (_ : ((fun a => ↑a) S).arrows { Y := Y✝, f := f✝, hf := hf✝ }.f) } =
    ↑x (Cover.Arrow.map { Y := Y✝, f := f✝, hf := hf✝ } h1.unop)
[PROOFSTEP]
rfl
[GOAL]
case h.e'_3.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (Cover J X)ᵒᵖ
h1 : op S ⟶ W
h2 : op T ⟶ W
I : Cover.Arrow W.unop
hh :
  ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x)) =
    ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h2) (↑(Meq.equiv P T).symm y))
e_1✝ :
  (forget D).obj (P.obj (op I.Y)) =
    (fun x => (forget D).obj (MulticospanIndex.left (Cover.index W.unop P) I))
      (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x))
⊢ ↑(Meq.refine y h2.unop) I =
    ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h2) (↑(Meq.equiv P T).symm y))
[PROOFSTEP]
dsimp [diagram]
[GOAL]
case h.e'_3.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (Cover J X)ᵒᵖ
h1 : op S ⟶ W
h2 : op T ⟶ W
I : Cover.Arrow W.unop
hh :
  ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x)) =
    ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h2) (↑(Meq.equiv P T).symm y))
e_1✝ :
  (forget D).obj (P.obj (op I.Y)) =
    (fun x => (forget D).obj (MulticospanIndex.left (Cover.index W.unop P) I))
      (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x))
⊢ ↑y { Y := I.Y, f := I.f, hf := (_ : ((fun a => ↑a) T).arrows I.f) } =
    ↑(Multiequalizer.ι (Cover.index W.unop P) I)
      (↑(Multiequalizer.lift (Cover.index W.unop P) (multiequalizer (Cover.index T P))
            (fun I => Multiequalizer.ι (Cover.index T P) (Cover.Arrow.map I h2.unop))
            (_ :
              ∀ (I : (Cover.index W.unop P).R),
                Multiequalizer.ι (Cover.index (op T).unop P)
                      (MulticospanIndex.fstTo (Cover.index (op T).unop P) (Cover.Relation.map I h2.unop)) ≫
                    MulticospanIndex.fst (Cover.index (op T).unop P) (Cover.Relation.map I h2.unop) =
                  Multiequalizer.ι (Cover.index (op T).unop P)
                      (MulticospanIndex.sndTo (Cover.index (op T).unop P) (Cover.Relation.map I h2.unop)) ≫
                    MulticospanIndex.snd (Cover.index (op T).unop P) (Cover.Relation.map I h2.unop)))
        (↑(Meq.equiv P T).symm y))
[PROOFSTEP]
erw [← comp_apply, Multiequalizer.lift_ι, Meq.equiv_symm_eq_apply]
[GOAL]
case h.e'_3.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (Cover J X)ᵒᵖ
h1 : op S ⟶ W
h2 : op T ⟶ W
I : Cover.Arrow W.unop
hh :
  ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x)) =
    ↑(Multiequalizer.ι (Cover.index W.unop P) I) (↑((diagram J P X).map h2) (↑(Meq.equiv P T).symm y))
e_1✝ :
  (forget D).obj (P.obj (op I.Y)) =
    (fun x => (forget D).obj (MulticospanIndex.left (Cover.index W.unop P) I))
      (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x))
⊢ ↑y { Y := I.Y, f := I.f, hf := (_ : ((fun a => ↑a) T).arrows I.f) } = ↑y (Cover.Arrow.map I h2.unop)
[PROOFSTEP]
cases I
[GOAL]
case h.e'_3.h.mk
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (Cover J X)ᵒᵖ
h1 : op S ⟶ W
h2 : op T ⟶ W
Y✝ : C
f✝ : Y✝ ⟶ X
hf✝ : (Cover.sieve W.unop).arrows f✝
hh :
  ↑(Multiequalizer.ι (Cover.index W.unop P) { Y := Y✝, f := f✝, hf := hf✝ })
      (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x)) =
    ↑(Multiequalizer.ι (Cover.index W.unop P) { Y := Y✝, f := f✝, hf := hf✝ })
      (↑((diagram J P X).map h2) (↑(Meq.equiv P T).symm y))
e_1✝ :
  (forget D).obj (P.obj (op { Y := Y✝, f := f✝, hf := hf✝ }.Y)) =
    (fun x => (forget D).obj (MulticospanIndex.left (Cover.index W.unop P) { Y := Y✝, f := f✝, hf := hf✝ }))
      (↑((diagram J P X).map h1) (↑(Meq.equiv P S).symm x))
⊢ ↑y
      { Y := { Y := Y✝, f := f✝, hf := hf✝ }.Y, f := { Y := Y✝, f := f✝, hf := hf✝ }.f,
        hf := (_ : ((fun a => ↑a) T).arrows { Y := Y✝, f := f✝, hf := hf✝ }.f) } =
    ↑y (Cover.Arrow.map { Y := Y✝, f := f✝, hf := hf✝ } h2.unop)
[PROOFSTEP]
rfl
[GOAL]
case mpr
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : Cover J X
x : Meq P S
y : Meq P T
⊢ (∃ W h1 h2, Meq.refine x h1 = Meq.refine y h2) → mk x = mk y
[PROOFSTEP]
rintro ⟨S, h1, h2, e⟩
[GOAL]
case mpr.intro.intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
e : Meq.refine x h1 = Meq.refine y h2
⊢ mk x = mk y
[PROOFSTEP]
apply Concrete.colimit_rep_eq_of_exists
[GOAL]
case mpr.intro.intro.intro.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
e : Meq.refine x h1 = Meq.refine y h2
⊢ ∃ k f g, ↑((diagram J P X).map f) (↑(Meq.equiv P S✝).symm x) = ↑((diagram J P X).map g) (↑(Meq.equiv P T).symm y)
[PROOFSTEP]
use op S, h1.op, h2.op
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
e : Meq.refine x h1 = Meq.refine y h2
⊢ ↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x) = ↑((diagram J P X).map h2.op) (↑(Meq.equiv P T).symm y)
[PROOFSTEP]
apply Concrete.multiequalizer_ext
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
e : Meq.refine x h1 = Meq.refine y h2
⊢ ∀ (t : (Cover.index (op S).unop P).L),
    ↑(Multiequalizer.ι (Cover.index (op S).unop P) t) (↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x)) =
      ↑(Multiequalizer.ι (Cover.index (op S).unop P) t) (↑((diagram J P X).map h2.op) (↑(Meq.equiv P T).symm y))
[PROOFSTEP]
intro i
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
e : Meq.refine x h1 = Meq.refine y h2
i : (Cover.index (op S).unop P).L
⊢ ↑(Multiequalizer.ι (Cover.index (op S).unop P) i) (↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x)) =
    ↑(Multiequalizer.ι (Cover.index (op S).unop P) i) (↑((diagram J P X).map h2.op) (↑(Meq.equiv P T).symm y))
[PROOFSTEP]
apply_fun fun ee => ee i at e 
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : (Cover.index (op S).unop P).L
e : ↑(Meq.refine x h1) i = ↑(Meq.refine y h2) i
⊢ ↑(Multiequalizer.ι (Cover.index (op S).unop P) i) (↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x)) =
    ↑(Multiequalizer.ι (Cover.index (op S).unop P) i) (↑((diagram J P X).map h2.op) (↑(Meq.equiv P T).symm y))
[PROOFSTEP]
convert e
[GOAL]
case h.e'_2.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : (Cover.index (op S).unop P).L
e : ↑(Meq.refine x h1) i = ↑(Meq.refine y h2) i
e_1✝ :
  (fun x => (forget D).obj (MulticospanIndex.left (Cover.index (op S).unop P) i))
      (↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x)) =
    (forget D).obj (P.obj (op i.Y))
⊢ ↑(Multiequalizer.ι (Cover.index (op S).unop P) i) (↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x)) =
    ↑(Meq.refine x h1) i
case h.e'_3.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : (Cover.index (op S).unop P).L
e : ↑(Meq.refine x h1) i = ↑(Meq.refine y h2) i
e_1✝ :
  (fun x => (forget D).obj (MulticospanIndex.left (Cover.index (op S).unop P) i))
      (↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x)) =
    (forget D).obj (P.obj (op i.Y))
⊢ ↑(Multiequalizer.ι (Cover.index (op S).unop P) i) (↑((diagram J P X).map h2.op) (↑(Meq.equiv P T).symm y)) =
    ↑(Meq.refine y h2) i
[PROOFSTEP]
all_goals
  dsimp [diagram]
  rw [← comp_apply, Multiequalizer.lift_ι]
  erw [Meq.equiv_symm_eq_apply]
  cases i; rfl
[GOAL]
case h.e'_2.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : (Cover.index (op S).unop P).L
e : ↑(Meq.refine x h1) i = ↑(Meq.refine y h2) i
e_1✝ :
  (fun x => (forget D).obj (MulticospanIndex.left (Cover.index (op S).unop P) i))
      (↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x)) =
    (forget D).obj (P.obj (op i.Y))
⊢ ↑(Multiequalizer.ι (Cover.index (op S).unop P) i) (↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x)) =
    ↑(Meq.refine x h1) i
[PROOFSTEP]
dsimp [diagram]
[GOAL]
case h.e'_2.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : (Cover.index (op S).unop P).L
e : ↑(Meq.refine x h1) i = ↑(Meq.refine y h2) i
e_1✝ :
  (fun x => (forget D).obj (MulticospanIndex.left (Cover.index (op S).unop P) i))
      (↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x)) =
    (forget D).obj (P.obj (op i.Y))
⊢ ↑(Multiequalizer.ι (Cover.index S P) i)
      (↑(Multiequalizer.lift (Cover.index S P) (multiequalizer (Cover.index S✝ P))
            (fun I => Multiequalizer.ι (Cover.index S✝ P) (Cover.Arrow.map I h1))
            (_ :
              ∀ (I : (Cover.index (op S).unop P).R),
                Multiequalizer.ι (Cover.index (op S✝).unop P)
                      (MulticospanIndex.fstTo (Cover.index (op S✝).unop P) (Cover.Relation.map I h1.op.unop)) ≫
                    MulticospanIndex.fst (Cover.index (op S✝).unop P) (Cover.Relation.map I h1.op.unop) =
                  Multiequalizer.ι (Cover.index (op S✝).unop P)
                      (MulticospanIndex.sndTo (Cover.index (op S✝).unop P) (Cover.Relation.map I h1.op.unop)) ≫
                    MulticospanIndex.snd (Cover.index (op S✝).unop P) (Cover.Relation.map I h1.op.unop)))
        (↑(Meq.equiv P S✝).symm x)) =
    ↑x { Y := i.Y, f := i.f, hf := (_ : ((fun a => ↑a) S✝).arrows i.f) }
[PROOFSTEP]
rw [← comp_apply, Multiequalizer.lift_ι]
[GOAL]
case h.e'_2.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : (Cover.index (op S).unop P).L
e : ↑(Meq.refine x h1) i = ↑(Meq.refine y h2) i
e_1✝ :
  (fun x => (forget D).obj (MulticospanIndex.left (Cover.index (op S).unop P) i))
      (↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x)) =
    (forget D).obj (P.obj (op i.Y))
⊢ ↑(Multiequalizer.ι (Cover.index S✝ P) (Cover.Arrow.map i h1)) (↑(Meq.equiv P S✝).symm x) =
    ↑x { Y := i.Y, f := i.f, hf := (_ : ((fun a => ↑a) S✝).arrows i.f) }
[PROOFSTEP]
erw [Meq.equiv_symm_eq_apply]
[GOAL]
case h.e'_2.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : (Cover.index (op S).unop P).L
e : ↑(Meq.refine x h1) i = ↑(Meq.refine y h2) i
e_1✝ :
  (fun x => (forget D).obj (MulticospanIndex.left (Cover.index (op S).unop P) i))
      (↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x)) =
    (forget D).obj (P.obj (op i.Y))
⊢ ↑x (Cover.Arrow.map i h1) = ↑x { Y := i.Y, f := i.f, hf := (_ : ((fun a => ↑a) S✝).arrows i.f) }
[PROOFSTEP]
cases i
[GOAL]
case h.e'_2.h.mk
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
Y✝ : C
f✝ : Y✝ ⟶ X
hf✝ : (Cover.sieve (op S).unop).arrows f✝
e : ↑(Meq.refine x h1) { Y := Y✝, f := f✝, hf := hf✝ } = ↑(Meq.refine y h2) { Y := Y✝, f := f✝, hf := hf✝ }
e_1✝ :
  (fun x => (forget D).obj (MulticospanIndex.left (Cover.index (op S).unop P) { Y := Y✝, f := f✝, hf := hf✝ }))
      (↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x)) =
    (forget D).obj (P.obj (op { Y := Y✝, f := f✝, hf := hf✝ }.Y))
⊢ ↑x (Cover.Arrow.map { Y := Y✝, f := f✝, hf := hf✝ } h1) =
    ↑x
      { Y := { Y := Y✝, f := f✝, hf := hf✝ }.Y, f := { Y := Y✝, f := f✝, hf := hf✝ }.f,
        hf := (_ : ((fun a => ↑a) S✝).arrows { Y := Y✝, f := f✝, hf := hf✝ }.f) }
[PROOFSTEP]
rfl
[GOAL]
case h.e'_3.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : (Cover.index (op S).unop P).L
e : ↑(Meq.refine x h1) i = ↑(Meq.refine y h2) i
e_1✝ :
  (fun x => (forget D).obj (MulticospanIndex.left (Cover.index (op S).unop P) i))
      (↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x)) =
    (forget D).obj (P.obj (op i.Y))
⊢ ↑(Multiequalizer.ι (Cover.index (op S).unop P) i) (↑((diagram J P X).map h2.op) (↑(Meq.equiv P T).symm y)) =
    ↑(Meq.refine y h2) i
[PROOFSTEP]
dsimp [diagram]
[GOAL]
case h.e'_3.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : (Cover.index (op S).unop P).L
e : ↑(Meq.refine x h1) i = ↑(Meq.refine y h2) i
e_1✝ :
  (fun x => (forget D).obj (MulticospanIndex.left (Cover.index (op S).unop P) i))
      (↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x)) =
    (forget D).obj (P.obj (op i.Y))
⊢ ↑(Multiequalizer.ι (Cover.index S P) i)
      (↑(Multiequalizer.lift (Cover.index S P) (multiequalizer (Cover.index T P))
            (fun I => Multiequalizer.ι (Cover.index T P) (Cover.Arrow.map I h2))
            (_ :
              ∀ (I : (Cover.index (op S).unop P).R),
                Multiequalizer.ι (Cover.index (op T).unop P)
                      (MulticospanIndex.fstTo (Cover.index (op T).unop P) (Cover.Relation.map I h2.op.unop)) ≫
                    MulticospanIndex.fst (Cover.index (op T).unop P) (Cover.Relation.map I h2.op.unop) =
                  Multiequalizer.ι (Cover.index (op T).unop P)
                      (MulticospanIndex.sndTo (Cover.index (op T).unop P) (Cover.Relation.map I h2.op.unop)) ≫
                    MulticospanIndex.snd (Cover.index (op T).unop P) (Cover.Relation.map I h2.op.unop)))
        (↑(Meq.equiv P T).symm y)) =
    ↑y { Y := i.Y, f := i.f, hf := (_ : ((fun a => ↑a) T).arrows i.f) }
[PROOFSTEP]
rw [← comp_apply, Multiequalizer.lift_ι]
[GOAL]
case h.e'_3.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : (Cover.index (op S).unop P).L
e : ↑(Meq.refine x h1) i = ↑(Meq.refine y h2) i
e_1✝ :
  (fun x => (forget D).obj (MulticospanIndex.left (Cover.index (op S).unop P) i))
      (↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x)) =
    (forget D).obj (P.obj (op i.Y))
⊢ ↑(Multiequalizer.ι (Cover.index T P) (Cover.Arrow.map i h2)) (↑(Meq.equiv P T).symm y) =
    ↑y { Y := i.Y, f := i.f, hf := (_ : ((fun a => ↑a) T).arrows i.f) }
[PROOFSTEP]
erw [Meq.equiv_symm_eq_apply]
[GOAL]
case h.e'_3.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : (Cover.index (op S).unop P).L
e : ↑(Meq.refine x h1) i = ↑(Meq.refine y h2) i
e_1✝ :
  (fun x => (forget D).obj (MulticospanIndex.left (Cover.index (op S).unop P) i))
      (↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x)) =
    (forget D).obj (P.obj (op i.Y))
⊢ ↑y (Cover.Arrow.map i h2) = ↑y { Y := i.Y, f := i.f, hf := (_ : ((fun a => ↑a) T).arrows i.f) }
[PROOFSTEP]
cases i
[GOAL]
case h.e'_3.h.mk
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : Cover J X
x : Meq P S✝
y : Meq P T
S : Cover J X
h1 : S ⟶ S✝
h2 : S ⟶ T
Y✝ : C
f✝ : Y✝ ⟶ X
hf✝ : (Cover.sieve (op S).unop).arrows f✝
e : ↑(Meq.refine x h1) { Y := Y✝, f := f✝, hf := hf✝ } = ↑(Meq.refine y h2) { Y := Y✝, f := f✝, hf := hf✝ }
e_1✝ :
  (fun x => (forget D).obj (MulticospanIndex.left (Cover.index (op S).unop P) { Y := Y✝, f := f✝, hf := hf✝ }))
      (↑((diagram J P X).map h1.op) (↑(Meq.equiv P S✝).symm x)) =
    (forget D).obj (P.obj (op { Y := Y✝, f := f✝, hf := hf✝ }.Y))
⊢ ↑y (Cover.Arrow.map { Y := Y✝, f := f✝, hf := hf✝ } h2) =
    ↑y
      { Y := { Y := Y✝, f := f✝, hf := hf✝ }.Y, f := { Y := Y✝, f := f✝, hf := hf✝ }.f,
        hf := (_ : ((fun a => ↑a) T).arrows { Y := Y✝, f := f✝, hf := hf✝ }.f) }
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x y : (forget D).obj ((plusObj J P).obj (op X))
h : ∀ (I : Cover.Arrow S), ↑((plusObj J P).map I.f.op) x = ↑((plusObj J P).map I.f.op) y
⊢ x = y
[PROOFSTEP]
obtain ⟨Sx, x, rfl⟩ := exists_rep x
[GOAL]
case intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
y : (forget D).obj ((plusObj J P).obj (op X))
Sx : Cover J X
x : Meq P Sx
h : ∀ (I : Cover.Arrow S), ↑((plusObj J P).map I.f.op) (mk x) = ↑((plusObj J P).map I.f.op) y
⊢ mk x = y
[PROOFSTEP]
obtain ⟨Sy, y, rfl⟩ := exists_rep y
[GOAL]
case intro.intro.intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), ↑((plusObj J P).map I.f.op) (mk x) = ↑((plusObj J P).map I.f.op) (mk y)
⊢ mk x = mk y
[PROOFSTEP]
simp only [res_mk_eq_mk_pullback] at h 
[GOAL]
case intro.intro.intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
⊢ mk x = mk y
[PROOFSTEP]
choose W h1 h2 hh using fun I : S.Arrow =>
  (eq_mk_iff_exists _ _).mp
    (h I)
      -- To prove equality, it suffices to prove that there exists a cover over which
        -- the representatives become equal.
[GOAL]
case intro.intro.intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
⊢ mk x = mk y
[PROOFSTEP]
rw [eq_mk_iff_exists]
  -- Construct the cover over which the representatives become equal by combining the various
    -- covers chosen above.
[GOAL]
case intro.intro.intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
⊢ ∃ W h1 h2, Meq.refine x h1 = Meq.refine y h2
[PROOFSTEP]
let B : J.Cover X := S.bind W
[GOAL]
case intro.intro.intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
⊢ ∃ W h1 h2, Meq.refine x h1 = Meq.refine y h2
[PROOFSTEP]
use B
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
⊢ ∃ h1 h2, Meq.refine x h1 = Meq.refine y h2
[PROOFSTEP]
let ex : B ⟶ Sx :=
  homOfLE
    (by
      rintro Y f ⟨Z, e1, e2, he2, he1, hee⟩
      rw [← hee]
      apply leOfHom (h1 ⟨_, _, he2⟩)
      exact he1)
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
⊢ B ≤ Sx
[PROOFSTEP]
rintro Y f ⟨Z, e1, e2, he2, he1, hee⟩
[GOAL]
case intro.intro.intro.intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
Y : C
f : Y ⟶ X
Z : C
e1 : Y ⟶ Z
e2 : Z ⟶ X
he2 : (Cover.sieve S).arrows e2
he1 : ((fun Y f hf => Cover.sieve (W { Y := Y, f := f, hf := hf })) Z e2 he2).arrows e1
hee : e1 ≫ e2 = f
⊢ ((fun a => ↑a) Sx).arrows f
[PROOFSTEP]
rw [← hee]
[GOAL]
case intro.intro.intro.intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
Y : C
f : Y ⟶ X
Z : C
e1 : Y ⟶ Z
e2 : Z ⟶ X
he2 : (Cover.sieve S).arrows e2
he1 : ((fun Y f hf => Cover.sieve (W { Y := Y, f := f, hf := hf })) Z e2 he2).arrows e1
hee : e1 ≫ e2 = f
⊢ ((fun a => ↑a) Sx).arrows (e1 ≫ e2)
[PROOFSTEP]
apply leOfHom (h1 ⟨_, _, he2⟩)
[GOAL]
case intro.intro.intro.intro.intro.a
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
Y : C
f : Y ⟶ X
Z : C
e1 : Y ⟶ Z
e2 : Z ⟶ X
he2 : (Cover.sieve S).arrows e2
he1 : ((fun Y f hf => Cover.sieve (W { Y := Y, f := f, hf := hf })) Z e2 he2).arrows e1
hee : e1 ≫ e2 = f
⊢ ((fun a => ↑a) (W { Y := Z, f := e2, hf := he2 })).arrows e1
[PROOFSTEP]
exact he1
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
⊢ ∃ h1 h2, Meq.refine x h1 = Meq.refine y h2
[PROOFSTEP]
let ey : B ⟶ Sy :=
  homOfLE
    (by
      rintro Y f ⟨Z, e1, e2, he2, he1, hee⟩
      rw [← hee]
      apply leOfHom (h2 ⟨_, _, he2⟩)
      exact he1)
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
⊢ B ≤ Sy
[PROOFSTEP]
rintro Y f ⟨Z, e1, e2, he2, he1, hee⟩
[GOAL]
case intro.intro.intro.intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
Y : C
f : Y ⟶ X
Z : C
e1 : Y ⟶ Z
e2 : Z ⟶ X
he2 : (Cover.sieve S).arrows e2
he1 : ((fun Y f hf => Cover.sieve (W { Y := Y, f := f, hf := hf })) Z e2 he2).arrows e1
hee : e1 ≫ e2 = f
⊢ ((fun a => ↑a) Sy).arrows f
[PROOFSTEP]
rw [← hee]
[GOAL]
case intro.intro.intro.intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
Y : C
f : Y ⟶ X
Z : C
e1 : Y ⟶ Z
e2 : Z ⟶ X
he2 : (Cover.sieve S).arrows e2
he1 : ((fun Y f hf => Cover.sieve (W { Y := Y, f := f, hf := hf })) Z e2 he2).arrows e1
hee : e1 ≫ e2 = f
⊢ ((fun a => ↑a) Sy).arrows (e1 ≫ e2)
[PROOFSTEP]
apply leOfHom (h2 ⟨_, _, he2⟩)
[GOAL]
case intro.intro.intro.intro.intro.a
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
Y : C
f : Y ⟶ X
Z : C
e1 : Y ⟶ Z
e2 : Z ⟶ X
he2 : (Cover.sieve S).arrows e2
he1 : ((fun Y f hf => Cover.sieve (W { Y := Y, f := f, hf := hf })) Z e2 he2).arrows e1
hee : e1 ≫ e2 = f
⊢ ((fun a => ↑a) (W { Y := Z, f := e2, hf := he2 })).arrows e1
[PROOFSTEP]
exact he1
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
⊢ ∃ h1 h2, Meq.refine x h1 = Meq.refine y h2
[PROOFSTEP]
use ex, ey
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
⊢ Meq.refine x ex = Meq.refine y ey
[PROOFSTEP]
ext1 I
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
⊢ ↑(Meq.refine x ex) I = ↑(Meq.refine y ey) I
[PROOFSTEP]
let IS : S.Arrow := I.fromMiddle
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
⊢ ↑(Meq.refine x ex) I = ↑(Meq.refine y ey) I
[PROOFSTEP]
specialize hh IS
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
hh : Meq.refine (Meq.pullback x IS.f) (h1 IS) = Meq.refine (Meq.pullback y IS.f) (h2 IS)
⊢ ↑(Meq.refine x ex) I = ↑(Meq.refine y ey) I
[PROOFSTEP]
let IW : (W IS).Arrow := I.toMiddle
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
hh : Meq.refine (Meq.pullback x IS.f) (h1 IS) = Meq.refine (Meq.pullback y IS.f) (h2 IS)
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
⊢ ↑(Meq.refine x ex) I = ↑(Meq.refine y ey) I
[PROOFSTEP]
apply_fun fun e => e IW at hh 
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
⊢ ↑(Meq.refine x ex) I = ↑(Meq.refine y ey) I
[PROOFSTEP]
convert hh using 1
[GOAL]
case h.e'_2.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj (op I.Y)) = (forget D).obj (P.obj (op IW.Y))
⊢ ↑(Meq.refine x ex) I = ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW
[PROOFSTEP]
let Rx : Sx.Relation :=
  ⟨I.Y, I.Y, I.Y, 𝟙 _, 𝟙 _, I.f, I.toMiddleHom ≫ I.fromMiddleHom, leOfHom ex _ I.hf, by
    simpa only [I.middle_spec] using leOfHom ex _ I.hf, by simp [I.middle_spec]⟩
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj (op I.Y)) = (forget D).obj (P.obj (op IW.Y))
⊢ (Cover.sieve Sx).arrows (Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I)
[PROOFSTEP]
simpa only [I.middle_spec] using leOfHom ex _ I.hf
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj (op I.Y)) = (forget D).obj (P.obj (op IW.Y))
⊢ 𝟙 I.Y ≫ I.f = 𝟙 I.Y ≫ Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I
[PROOFSTEP]
simp [I.middle_spec]
[GOAL]
case h.e'_2.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj (op I.Y)) = (forget D).obj (P.obj (op IW.Y))
Rx : Cover.Relation Sx :=
  { Y₁ := I.Y, Y₂ := I.Y, Z := I.Y, g₁ := 𝟙 I.Y, g₂ := 𝟙 I.Y, f₁ := I.f,
    f₂ := Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I, h₁ := (_ : ((fun a => ↑a) Sx).arrows I.f),
    h₂ := (_ : (Cover.sieve Sx).arrows (Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I)),
    w := (_ : 𝟙 I.Y ≫ I.f = 𝟙 I.Y ≫ Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I) }
⊢ ↑(Meq.refine x ex) I = ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW
[PROOFSTEP]
simpa [id_apply] using x.condition Rx
[GOAL]
case h.e'_3.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj (op I.Y)) = (forget D).obj (P.obj (op IW.Y))
⊢ ↑(Meq.refine y ey) I = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
[PROOFSTEP]
let Ry : Sy.Relation :=
  ⟨I.Y, I.Y, I.Y, 𝟙 _, 𝟙 _, I.f, I.toMiddleHom ≫ I.fromMiddleHom, leOfHom ey _ I.hf, by
    simpa only [I.middle_spec] using leOfHom ey _ I.hf, by simp [I.middle_spec]⟩
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj (op I.Y)) = (forget D).obj (P.obj (op IW.Y))
⊢ (Cover.sieve Sy).arrows (Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I)
[PROOFSTEP]
simpa only [I.middle_spec] using leOfHom ey _ I.hf
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj (op I.Y)) = (forget D).obj (P.obj (op IW.Y))
⊢ 𝟙 I.Y ≫ I.f = 𝟙 I.Y ≫ Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I
[PROOFSTEP]
simp [I.middle_spec]
[GOAL]
case h.e'_3.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj (op I.Y)) = (forget D).obj (P.obj (op IW.Y))
Ry : Cover.Relation Sy :=
  { Y₁ := I.Y, Y₂ := I.Y, Z := I.Y, g₁ := 𝟙 I.Y, g₂ := 𝟙 I.Y, f₁ := I.f,
    f₂ := Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I, h₁ := (_ : ((fun a => ↑a) Sy).arrows I.f),
    h₂ := (_ : (Cover.sieve Sy).arrows (Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I)),
    w := (_ : 𝟙 I.Y ≫ I.f = 𝟙 I.Y ≫ Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I) }
⊢ ↑(Meq.refine y ey) I = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
[PROOFSTEP]
simpa [id_apply] using y.condition Ry
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
⊢ Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
[PROOFSTEP]
intro x y h
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
x y : (forget D).obj (P.obj (op X))
h : ↑(NatTrans.app (toPlus J P) (op X)) x = ↑(NatTrans.app (toPlus J P) (op X)) y
⊢ x = y
[PROOFSTEP]
simp only [toPlus_eq_mk] at h 
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
x y : (forget D).obj (P.obj (op X))
h : mk (Meq.mk ⊤ x) = mk (Meq.mk ⊤ y)
⊢ x = y
[PROOFSTEP]
rw [eq_mk_iff_exists] at h 
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
x y : (forget D).obj (P.obj (op X))
h : ∃ W h1 h2, Meq.refine (Meq.mk ⊤ x) h1 = Meq.refine (Meq.mk ⊤ y) h2
⊢ x = y
[PROOFSTEP]
obtain ⟨W, h1, h2, hh⟩ := h
[GOAL]
case intro.intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
x y : (forget D).obj (P.obj (op X))
W : Cover J X
h1 h2 : W ⟶ ⊤
hh : Meq.refine (Meq.mk ⊤ x) h1 = Meq.refine (Meq.mk ⊤ y) h2
⊢ x = y
[PROOFSTEP]
apply hsep X W
[GOAL]
case intro.intro.intro.a
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
x y : (forget D).obj (P.obj (op X))
W : Cover J X
h1 h2 : W ⟶ ⊤
hh : Meq.refine (Meq.mk ⊤ x) h1 = Meq.refine (Meq.mk ⊤ y) h2
⊢ ∀ (I : Cover.Arrow W), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y
[PROOFSTEP]
intro I
[GOAL]
case intro.intro.intro.a
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
x y : (forget D).obj (P.obj (op X))
W : Cover J X
h1 h2 : W ⟶ ⊤
hh : Meq.refine (Meq.mk ⊤ x) h1 = Meq.refine (Meq.mk ⊤ y) h2
I : Cover.Arrow W
⊢ ↑(P.map I.f.op) x = ↑(P.map I.f.op) y
[PROOFSTEP]
apply_fun fun e => e I at hh 
[GOAL]
case intro.intro.intro.a
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
x y : (forget D).obj (P.obj (op X))
W : Cover J X
h1 h2 : W ⟶ ⊤
I : Cover.Arrow W
hh : ↑(Meq.refine (Meq.mk ⊤ x) h1) I = ↑(Meq.refine (Meq.mk ⊤ y) h2) I
⊢ ↑(P.map I.f.op) x = ↑(P.map I.f.op) y
[PROOFSTEP]
exact hh
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
⊢ ∀ (I : Cover.Relation (Cover.bind S T)),
    ↑(P.map I.g₁.op) ((fun I => ↑(t (Cover.Arrow.fromMiddle I)) (Cover.Arrow.toMiddle I)) (Cover.Relation.fst I)) =
      ↑(P.map I.g₂.op) ((fun I => ↑(t (Cover.Arrow.fromMiddle I)) (Cover.Arrow.toMiddle I)) (Cover.Relation.snd I))
[PROOFSTEP]
intro II
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
II : Cover.Relation (Cover.bind S T)
⊢ ↑(P.map II.g₁.op) ((fun I => ↑(t (Cover.Arrow.fromMiddle I)) (Cover.Arrow.toMiddle I)) (Cover.Relation.fst II)) =
    ↑(P.map II.g₂.op) ((fun I => ↑(t (Cover.Arrow.fromMiddle I)) (Cover.Arrow.toMiddle I)) (Cover.Relation.snd II))
[PROOFSTEP]
apply inj_of_sep P hsep
[GOAL]
case a
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
II : Cover.Relation (Cover.bind S T)
⊢ ↑(NatTrans.app (toPlus J P) (op II.Z))
      (↑(P.map II.g₁.op)
        ((fun I => ↑(t (Cover.Arrow.fromMiddle I)) (Cover.Arrow.toMiddle I)) (Cover.Relation.fst II))) =
    ↑(NatTrans.app (toPlus J P) (op II.Z))
      (↑(P.map II.g₂.op) ((fun I => ↑(t (Cover.Arrow.fromMiddle I)) (Cover.Arrow.toMiddle I)) (Cover.Relation.snd II)))
[PROOFSTEP]
rw [← comp_apply, ← comp_apply, (J.toPlus P).naturality, (J.toPlus P).naturality, comp_apply, comp_apply]
[GOAL]
case a
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
II : Cover.Relation (Cover.bind S T)
⊢ ↑((plusObj J P).map II.g₁.op)
      (↑(NatTrans.app (toPlus J P) (op II.Y₁))
        ((fun I => ↑(t (Cover.Arrow.fromMiddle I)) (Cover.Arrow.toMiddle I)) (Cover.Relation.fst II))) =
    ↑((plusObj J P).map II.g₂.op)
      (↑(NatTrans.app (toPlus J P) (op II.Y₂))
        ((fun I => ↑(t (Cover.Arrow.fromMiddle I)) (Cover.Arrow.toMiddle I)) (Cover.Relation.snd II)))
[PROOFSTEP]
erw [toPlus_apply (T II.fst.fromMiddle) (t II.fst.fromMiddle) II.fst.toMiddle,
  toPlus_apply (T II.snd.fromMiddle) (t II.snd.fromMiddle) II.snd.toMiddle, ← ht, ← ht, ← comp_apply, ← comp_apply, ←
  (J.plusObj P).map_comp, ← (J.plusObj P).map_comp]
[GOAL]
case a
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
II : Cover.Relation (Cover.bind S T)
⊢ ↑((plusObj J P).map ((Cover.Arrow.toMiddle (Cover.Relation.fst II)).f.op ≫ II.g₁.op))
      (↑s (Cover.Arrow.fromMiddle (Cover.Relation.fst II))) =
    ↑((plusObj J P).map ((Cover.Arrow.toMiddle (Cover.Relation.snd II)).f.op ≫ II.g₂.op))
      (↑s (Cover.Arrow.fromMiddle (Cover.Relation.snd II)))
[PROOFSTEP]
rw [← op_comp, ← op_comp]
[GOAL]
case a
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
II : Cover.Relation (Cover.bind S T)
⊢ ↑((plusObj J P).map (II.g₁ ≫ (Cover.Arrow.toMiddle (Cover.Relation.fst II)).f).op)
      (↑s (Cover.Arrow.fromMiddle (Cover.Relation.fst II))) =
    ↑((plusObj J P).map (II.g₂ ≫ (Cover.Arrow.toMiddle (Cover.Relation.snd II)).f).op)
      (↑s (Cover.Arrow.fromMiddle (Cover.Relation.snd II)))
[PROOFSTEP]
let IR : S.Relation :=
  ⟨_, _, _, II.g₁ ≫ II.fst.toMiddleHom, II.g₂ ≫ II.snd.toMiddleHom, II.fst.fromMiddleHom, II.snd.fromMiddleHom,
    II.fst.from_middle_condition, II.snd.from_middle_condition, by
    simpa only [Category.assoc, II.fst.middle_spec, II.snd.middle_spec] using II.w⟩
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
II : Cover.Relation (Cover.bind S T)
⊢ (II.g₁ ≫ Cover.Arrow.toMiddleHom (Cover.Relation.fst II)) ≫ Cover.Arrow.fromMiddleHom (Cover.Relation.fst II) =
    (II.g₂ ≫ Cover.Arrow.toMiddleHom (Cover.Relation.snd II)) ≫ Cover.Arrow.fromMiddleHom (Cover.Relation.snd II)
[PROOFSTEP]
simpa only [Category.assoc, II.fst.middle_spec, II.snd.middle_spec] using II.w
[GOAL]
case a
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
II : Cover.Relation (Cover.bind S T)
IR : Cover.Relation S :=
  { Y₁ := Cover.Arrow.middle (Cover.Relation.fst II), Y₂ := Cover.Arrow.middle (Cover.Relation.snd II), Z := II.Z,
    g₁ := II.g₁ ≫ Cover.Arrow.toMiddleHom (Cover.Relation.fst II),
    g₂ := II.g₂ ≫ Cover.Arrow.toMiddleHom (Cover.Relation.snd II),
    f₁ := Cover.Arrow.fromMiddleHom (Cover.Relation.fst II), f₂ := Cover.Arrow.fromMiddleHom (Cover.Relation.snd II),
    h₁ := (_ : (Cover.sieve S).arrows (Cover.Arrow.fromMiddleHom (Cover.Relation.fst II))),
    h₂ := (_ : (Cover.sieve S).arrows (Cover.Arrow.fromMiddleHom (Cover.Relation.snd II))),
    w :=
      (_ :
        (II.g₁ ≫ Cover.Arrow.toMiddleHom (Cover.Relation.fst II)) ≫ Cover.Arrow.fromMiddleHom (Cover.Relation.fst II) =
          (II.g₂ ≫ Cover.Arrow.toMiddleHom (Cover.Relation.snd II)) ≫
            Cover.Arrow.fromMiddleHom (Cover.Relation.snd II)) }
⊢ ↑((plusObj J P).map (II.g₁ ≫ (Cover.Arrow.toMiddle (Cover.Relation.fst II)).f).op)
      (↑s (Cover.Arrow.fromMiddle (Cover.Relation.fst II))) =
    ↑((plusObj J P).map (II.g₂ ≫ (Cover.Arrow.toMiddle (Cover.Relation.snd II)).f).op)
      (↑s (Cover.Arrow.fromMiddle (Cover.Relation.snd II)))
[PROOFSTEP]
exact s.condition IR
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
⊢ ∃ t, Meq.mk S t = s
[PROOFSTEP]
have inj : ∀ X : C, Function.Injective ((J.toPlus P).app (op X)) := inj_of_sep _ hsep
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
⊢ ∃ t, Meq.mk S t = s
[PROOFSTEP]
choose T t ht using fun I =>
  exists_rep
    (s I)
      -- Construct a large cover over which we will define a representative that will
        -- provide the gluing of the given local sections.
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
⊢ ∃ t, Meq.mk S t = s
[PROOFSTEP]
let B : J.Cover X := S.bind T
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
⊢ ∃ t, Meq.mk S t = s
[PROOFSTEP]
choose Z e1 e2 he2 _ _ using fun I : B.Arrow => I.hf
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
⊢ ∃ t, Meq.mk S t = s
[PROOFSTEP]
let w : Meq P B := meqOfSep P hsep X S s T t ht
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
⊢ ∃ t, Meq.mk S t = s
[PROOFSTEP]
use mk w
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
⊢ Meq.mk S (mk w) = s
[PROOFSTEP]
ext I
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
⊢ ↑(Meq.mk S (mk w)) I = ↑s I
[PROOFSTEP]
dsimp [Meq.mk]
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
⊢ ↑((plusObj J P).map I.f.op) (mk (meqOfSep P hsep X S s T t ht)) = ↑s I
[PROOFSTEP]
erw [ht, res_mk_eq_mk_pullback]
  -- Use the separatedness of `P⁺` to prove that this is indeed a gluing of our
    -- original local sections.
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
⊢ mk (Meq.pullback (meqOfSep P hsep X S s T t ht) I.f) = mk (t I)
[PROOFSTEP]
apply sep P (T I)
[GOAL]
case h.h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
⊢ ∀ (I_1 : Cover.Arrow (T I)),
    ↑((plusObj J P).map I_1.f.op) (mk (Meq.pullback (meqOfSep P hsep X S s T t ht) I.f)) =
      ↑((plusObj J P).map I_1.f.op) (mk (t I))
[PROOFSTEP]
intro II
[GOAL]
case h.h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
II : Cover.Arrow (T I)
⊢ ↑((plusObj J P).map II.f.op) (mk (Meq.pullback (meqOfSep P hsep X S s T t ht) I.f)) =
    ↑((plusObj J P).map II.f.op) (mk (t I))
[PROOFSTEP]
simp only [res_mk_eq_mk_pullback, eq_mk_iff_exists]
  -- It suffices to prove equality for representatives over a
    -- convenient sufficiently large cover...
[GOAL]
case h.h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
II : Cover.Arrow (T I)
⊢ ∃ W h1 h2,
    Meq.refine (Meq.pullback (Meq.pullback (meqOfSep P hsep X S s T t ht) I.f) II.f) h1 =
      Meq.refine (Meq.pullback (t I) II.f) h2
[PROOFSTEP]
use(J.pullback II.f).obj (T I)
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
II : Cover.Arrow (T I)
⊢ ∃ h1 h2,
    Meq.refine (Meq.pullback (Meq.pullback (meqOfSep P hsep X S s T t ht) I.f) II.f) h1 =
      Meq.refine (Meq.pullback (t I) II.f) h2
[PROOFSTEP]
let e0 : (J.pullback II.f).obj (T I) ⟶ (J.pullback II.f).obj ((J.pullback I.f).obj B) :=
  homOfLE
    (by
      intro Y f hf
      apply Sieve.le_pullback_bind _ _ _ I.hf
      · cases I
        exact hf)
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
II : Cover.Arrow (T I)
⊢ (pullback J II.f).obj (T I) ≤ (pullback J II.f).obj ((pullback J I.f).obj B)
[PROOFSTEP]
intro Y f hf
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
II : Cover.Arrow (T I)
Y : C
f : Y ⟶ II.Y
hf : ((fun a => ↑a) ((pullback J II.f).obj (T I))).arrows f
⊢ ((fun a => ↑a) ((pullback J II.f).obj ((pullback J I.f).obj B))).arrows f
[PROOFSTEP]
apply Sieve.le_pullback_bind _ _ _ I.hf
[GOAL]
case a
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
II : Cover.Arrow (T I)
Y : C
f : Y ⟶ II.Y
hf : ((fun a => ↑a) ((pullback J II.f).obj (T I))).arrows f
⊢ ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) I.Y I.f (_ : (Cover.sieve S).arrows I.f)).arrows
    (f ≫ II.f)
[PROOFSTEP]
cases I
[GOAL]
case a.mk
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
Y Y✝ : C
f✝ : Y✝ ⟶ X
hf✝ : (Cover.sieve S).arrows f✝
II : Cover.Arrow (T { Y := Y✝, f := f✝, hf := hf✝ })
f : Y ⟶ II.Y
hf : ((fun a => ↑a) ((pullback J II.f).obj (T { Y := Y✝, f := f✝, hf := hf✝ }))).arrows f
⊢ ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) { Y := Y✝, f := f✝, hf := hf✝ }.Y
        { Y := Y✝, f := f✝, hf := hf✝ }.f (_ : (Cover.sieve S).arrows { Y := Y✝, f := f✝, hf := hf✝ }.f)).arrows
    (f ≫ II.f)
[PROOFSTEP]
exact hf
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
II : Cover.Arrow (T I)
e0 : (pullback J II.f).obj (T I) ⟶ (pullback J II.f).obj ((pullback J I.f).obj B) :=
  homOfLE
    (_ :
      ∀ ⦃Y : C⦄ (f : Y ⟶ II.Y),
        ((fun a => ↑a) ((pullback J II.f).obj (T I))).arrows f →
          (Sieve.pullback I.f
                (Sieve.bind (Cover.sieve S).arrows fun Y f H =>
                  (fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f H)).arrows
            (f ≫ II.f))
⊢ ∃ h1 h2,
    Meq.refine (Meq.pullback (Meq.pullback (meqOfSep P hsep X S s T t ht) I.f) II.f) h1 =
      Meq.refine (Meq.pullback (t I) II.f) h2
[PROOFSTEP]
use e0, 𝟙 _
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
II : Cover.Arrow (T I)
e0 : (pullback J II.f).obj (T I) ⟶ (pullback J II.f).obj ((pullback J I.f).obj B) :=
  homOfLE
    (_ :
      ∀ ⦃Y : C⦄ (f : Y ⟶ II.Y),
        ((fun a => ↑a) ((pullback J II.f).obj (T I))).arrows f →
          (Sieve.pullback I.f
                (Sieve.bind (Cover.sieve S).arrows fun Y f H =>
                  (fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f H)).arrows
            (f ≫ II.f))
⊢ Meq.refine (Meq.pullback (Meq.pullback (meqOfSep P hsep X S s T t ht) I.f) II.f) e0 =
    Meq.refine (Meq.pullback (t I) II.f) (𝟙 ((pullback J II.f).obj (T I)))
[PROOFSTEP]
ext IV
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
II : Cover.Arrow (T I)
e0 : (pullback J II.f).obj (T I) ⟶ (pullback J II.f).obj ((pullback J I.f).obj B) :=
  homOfLE
    (_ :
      ∀ ⦃Y : C⦄ (f : Y ⟶ II.Y),
        ((fun a => ↑a) ((pullback J II.f).obj (T I))).arrows f →
          (Sieve.pullback I.f
                (Sieve.bind (Cover.sieve S).arrows fun Y f H =>
                  (fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f H)).arrows
            (f ≫ II.f))
IV : Cover.Arrow ((pullback J II.f).obj (T I))
⊢ ↑(Meq.refine (Meq.pullback (Meq.pullback (meqOfSep P hsep X S s T t ht) I.f) II.f) e0) IV =
    ↑(Meq.refine (Meq.pullback (t I) II.f) (𝟙 ((pullback J II.f).obj (T I)))) IV
[PROOFSTEP]
let IA : B.Arrow := ⟨_, (IV.f ≫ II.f) ≫ I.f, ⟨I.Y, _, _, I.hf, Sieve.downward_closed _ II.hf _, rfl⟩⟩
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
II : Cover.Arrow (T I)
e0 : (pullback J II.f).obj (T I) ⟶ (pullback J II.f).obj ((pullback J I.f).obj B) :=
  homOfLE
    (_ :
      ∀ ⦃Y : C⦄ (f : Y ⟶ II.Y),
        ((fun a => ↑a) ((pullback J II.f).obj (T I))).arrows f →
          (Sieve.pullback I.f
                (Sieve.bind (Cover.sieve S).arrows fun Y f H =>
                  (fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f H)).arrows
            (f ≫ II.f))
IV : Cover.Arrow ((pullback J II.f).obj (T I))
IA : Cover.Arrow B :=
  { Y := IV.Y, f := (IV.f ≫ II.f) ≫ I.f,
    hf :=
      (_ :
        ∃ Y g f H,
          (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) Y f H g ∧
            g ≫ f = (IV.f ≫ II.f) ≫ I.f) }
⊢ ↑(Meq.refine (Meq.pullback (Meq.pullback (meqOfSep P hsep X S s T t ht) I.f) II.f) e0) IV =
    ↑(Meq.refine (Meq.pullback (t I) II.f) (𝟙 ((pullback J II.f).obj (T I)))) IV
[PROOFSTEP]
let IB : S.Arrow := IA.fromMiddle
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
II : Cover.Arrow (T I)
e0 : (pullback J II.f).obj (T I) ⟶ (pullback J II.f).obj ((pullback J I.f).obj B) :=
  homOfLE
    (_ :
      ∀ ⦃Y : C⦄ (f : Y ⟶ II.Y),
        ((fun a => ↑a) ((pullback J II.f).obj (T I))).arrows f →
          (Sieve.pullback I.f
                (Sieve.bind (Cover.sieve S).arrows fun Y f H =>
                  (fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f H)).arrows
            (f ≫ II.f))
IV : Cover.Arrow ((pullback J II.f).obj (T I))
IA : Cover.Arrow B :=
  { Y := IV.Y, f := (IV.f ≫ II.f) ≫ I.f,
    hf :=
      (_ :
        ∃ Y g f H,
          (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) Y f H g ∧
            g ≫ f = (IV.f ≫ II.f) ≫ I.f) }
IB : Cover.Arrow S := Cover.Arrow.fromMiddle IA
⊢ ↑(Meq.refine (Meq.pullback (Meq.pullback (meqOfSep P hsep X S s T t ht) I.f) II.f) e0) IV =
    ↑(Meq.refine (Meq.pullback (t I) II.f) (𝟙 ((pullback J II.f).obj (T I)))) IV
[PROOFSTEP]
let IC : (T IB).Arrow := IA.toMiddle
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
II : Cover.Arrow (T I)
e0 : (pullback J II.f).obj (T I) ⟶ (pullback J II.f).obj ((pullback J I.f).obj B) :=
  homOfLE
    (_ :
      ∀ ⦃Y : C⦄ (f : Y ⟶ II.Y),
        ((fun a => ↑a) ((pullback J II.f).obj (T I))).arrows f →
          (Sieve.pullback I.f
                (Sieve.bind (Cover.sieve S).arrows fun Y f H =>
                  (fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f H)).arrows
            (f ≫ II.f))
IV : Cover.Arrow ((pullback J II.f).obj (T I))
IA : Cover.Arrow B :=
  { Y := IV.Y, f := (IV.f ≫ II.f) ≫ I.f,
    hf :=
      (_ :
        ∃ Y g f H,
          (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) Y f H g ∧
            g ≫ f = (IV.f ≫ II.f) ≫ I.f) }
IB : Cover.Arrow S := Cover.Arrow.fromMiddle IA
IC : Cover.Arrow (T IB) := Cover.Arrow.toMiddle IA
⊢ ↑(Meq.refine (Meq.pullback (Meq.pullback (meqOfSep P hsep X S s T t ht) I.f) II.f) e0) IV =
    ↑(Meq.refine (Meq.pullback (t I) II.f) (𝟙 ((pullback J II.f).obj (T I)))) IV
[PROOFSTEP]
let ID : (T I).Arrow := ⟨IV.Y, IV.f ≫ II.f, Sieve.downward_closed (T I).sieve II.hf IV.f⟩
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
II : Cover.Arrow (T I)
e0 : (pullback J II.f).obj (T I) ⟶ (pullback J II.f).obj ((pullback J I.f).obj B) :=
  homOfLE
    (_ :
      ∀ ⦃Y : C⦄ (f : Y ⟶ II.Y),
        ((fun a => ↑a) ((pullback J II.f).obj (T I))).arrows f →
          (Sieve.pullback I.f
                (Sieve.bind (Cover.sieve S).arrows fun Y f H =>
                  (fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f H)).arrows
            (f ≫ II.f))
IV : Cover.Arrow ((pullback J II.f).obj (T I))
IA : Cover.Arrow B :=
  { Y := IV.Y, f := (IV.f ≫ II.f) ≫ I.f,
    hf :=
      (_ :
        ∃ Y g f H,
          (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) Y f H g ∧
            g ≫ f = (IV.f ≫ II.f) ≫ I.f) }
IB : Cover.Arrow S := Cover.Arrow.fromMiddle IA
IC : Cover.Arrow (T IB) := Cover.Arrow.toMiddle IA
ID : Cover.Arrow (T I) := { Y := IV.Y, f := IV.f ≫ II.f, hf := (_ : (Cover.sieve (T I)).arrows (IV.f ≫ II.f)) }
⊢ ↑(Meq.refine (Meq.pullback (Meq.pullback (meqOfSep P hsep X S s T t ht) I.f) II.f) e0) IV =
    ↑(Meq.refine (Meq.pullback (t I) II.f) (𝟙 ((pullback J II.f).obj (T I)))) IV
[PROOFSTEP]
change t IB IC = t I ID
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
II : Cover.Arrow (T I)
e0 : (pullback J II.f).obj (T I) ⟶ (pullback J II.f).obj ((pullback J I.f).obj B) :=
  homOfLE
    (_ :
      ∀ ⦃Y : C⦄ (f : Y ⟶ II.Y),
        ((fun a => ↑a) ((pullback J II.f).obj (T I))).arrows f →
          (Sieve.pullback I.f
                (Sieve.bind (Cover.sieve S).arrows fun Y f H =>
                  (fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f H)).arrows
            (f ≫ II.f))
IV : Cover.Arrow ((pullback J II.f).obj (T I))
IA : Cover.Arrow B :=
  { Y := IV.Y, f := (IV.f ≫ II.f) ≫ I.f,
    hf :=
      (_ :
        ∃ Y g f H,
          (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) Y f H g ∧
            g ≫ f = (IV.f ≫ II.f) ≫ I.f) }
IB : Cover.Arrow S := Cover.Arrow.fromMiddle IA
IC : Cover.Arrow (T IB) := Cover.Arrow.toMiddle IA
ID : Cover.Arrow (T I) := { Y := IV.Y, f := IV.f ≫ II.f, hf := (_ : (Cover.sieve (T I)).arrows (IV.f ≫ II.f)) }
⊢ ↑(t IB) IC = ↑(t I) ID
[PROOFSTEP]
apply inj IV.Y
[GOAL]
case h.h.a
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
II : Cover.Arrow (T I)
e0 : (pullback J II.f).obj (T I) ⟶ (pullback J II.f).obj ((pullback J I.f).obj B) :=
  homOfLE
    (_ :
      ∀ ⦃Y : C⦄ (f : Y ⟶ II.Y),
        ((fun a => ↑a) ((pullback J II.f).obj (T I))).arrows f →
          (Sieve.pullback I.f
                (Sieve.bind (Cover.sieve S).arrows fun Y f H =>
                  (fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f H)).arrows
            (f ≫ II.f))
IV : Cover.Arrow ((pullback J II.f).obj (T I))
IA : Cover.Arrow B :=
  { Y := IV.Y, f := (IV.f ≫ II.f) ≫ I.f,
    hf :=
      (_ :
        ∃ Y g f H,
          (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) Y f H g ∧
            g ≫ f = (IV.f ≫ II.f) ≫ I.f) }
IB : Cover.Arrow S := Cover.Arrow.fromMiddle IA
IC : Cover.Arrow (T IB) := Cover.Arrow.toMiddle IA
ID : Cover.Arrow (T I) := { Y := IV.Y, f := IV.f ≫ II.f, hf := (_ : (Cover.sieve (T I)).arrows (IV.f ≫ II.f)) }
⊢ ↑(NatTrans.app (toPlus J P) (op IV.Y)) (↑(t IB) IC) = ↑(NatTrans.app (toPlus J P) (op IV.Y)) (↑(t I) ID)
[PROOFSTEP]
erw [toPlus_apply (T I) (t I) ID, toPlus_apply (T IB) (t IB) IC, ← ht, ← ht]
  -- Conclude by constructing the relation showing equality...
[GOAL]
case h.h.a
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
II : Cover.Arrow (T I)
e0 : (pullback J II.f).obj (T I) ⟶ (pullback J II.f).obj ((pullback J I.f).obj B) :=
  homOfLE
    (_ :
      ∀ ⦃Y : C⦄ (f : Y ⟶ II.Y),
        ((fun a => ↑a) ((pullback J II.f).obj (T I))).arrows f →
          (Sieve.pullback I.f
                (Sieve.bind (Cover.sieve S).arrows fun Y f H =>
                  (fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f H)).arrows
            (f ≫ II.f))
IV : Cover.Arrow ((pullback J II.f).obj (T I))
IA : Cover.Arrow B :=
  { Y := IV.Y, f := (IV.f ≫ II.f) ≫ I.f,
    hf :=
      (_ :
        ∃ Y g f H,
          (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) Y f H g ∧
            g ≫ f = (IV.f ≫ II.f) ≫ I.f) }
IB : Cover.Arrow S := Cover.Arrow.fromMiddle IA
IC : Cover.Arrow (T IB) := Cover.Arrow.toMiddle IA
ID : Cover.Arrow (T I) := { Y := IV.Y, f := IV.f ≫ II.f, hf := (_ : (Cover.sieve (T I)).arrows (IV.f ≫ II.f)) }
⊢ ↑((plusObj J P).map IC.f.op) (↑s IB) = ↑((plusObj J P).map ID.f.op) (↑s I)
[PROOFSTEP]
let IR : S.Relation := ⟨_, _, IV.Y, IC.f, ID.f, IB.f, I.f, IB.hf, I.hf, IA.middle_spec⟩
[GOAL]
case h.h.a
C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁵ : Category.{max v u, w} D
inst✝⁴ : ConcreteCategory D
inst✝³ : PreservesLimits (forget D)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
s : Meq (plusObj J P) S
inj : ∀ (X : C), Function.Injective ↑(NatTrans.app (toPlus J P) (op X))
T : (I : Cover.Arrow S) → Cover J I.Y
t : (I : Cover.Arrow S) → Meq P (T I)
ht : ∀ (I : Cover.Arrow S), ↑s I = mk (t I)
B : Cover J X := Cover.bind S T
Z : Cover.Arrow B → C
e1 : (I : Cover.Arrow B) → I.Y ⟶ Z I
e2 : (I : Cover.Arrow B) → Z I ⟶ X
he2 : ∀ (I : Cover.Arrow B), (Cover.sieve S).arrows (e2 I)
h✝ :
  ∀ (I : Cover.Arrow B),
    (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) (Z I) (e2 I)
      (_ : (Cover.sieve S).arrows (e2 I)) (e1 I)
✝ : ∀ (I : Cover.Arrow B), e1 I ≫ e2 I = I.f
w : Meq P B := meqOfSep P hsep X S s T t ht
I : Cover.Arrow S
II : Cover.Arrow (T I)
e0 : (pullback J II.f).obj (T I) ⟶ (pullback J II.f).obj ((pullback J I.f).obj B) :=
  homOfLE
    (_ :
      ∀ ⦃Y : C⦄ (f : Y ⟶ II.Y),
        ((fun a => ↑a) ((pullback J II.f).obj (T I))).arrows f →
          (Sieve.pullback I.f
                (Sieve.bind (Cover.sieve S).arrows fun Y f H =>
                  (fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f H)).arrows
            (f ≫ II.f))
IV : Cover.Arrow ((pullback J II.f).obj (T I))
IA : Cover.Arrow B :=
  { Y := IV.Y, f := (IV.f ≫ II.f) ≫ I.f,
    hf :=
      (_ :
        ∃ Y g f H,
          (fun Y f h => ((fun Y f hf => Cover.sieve (T { Y := Y, f := f, hf := hf })) Y f h).arrows) Y f H g ∧
            g ≫ f = (IV.f ≫ II.f) ≫ I.f) }
IB : Cover.Arrow S := Cover.Arrow.fromMiddle IA
IC : Cover.Arrow (T IB) := Cover.Arrow.toMiddle IA
ID : Cover.Arrow (T I) := { Y := IV.Y, f := IV.f ≫ II.f, hf := (_ : (Cover.sieve (T I)).arrows (IV.f ≫ II.f)) }
IR : Cover.Relation S :=
  { Y₁ := IB.Y, Y₂ := I.Y, Z := IV.Y, g₁ := IC.f, g₂ := ID.f, f₁ := IB.f, f₂ := I.f,
    h₁ := (_ : (Cover.sieve S).arrows IB.f), h₂ := (_ : (Cover.sieve S).arrows I.f),
    w := (_ : Cover.Arrow.toMiddleHom IA ≫ Cover.Arrow.fromMiddleHom IA = IA.f) }
⊢ ↑((plusObj J P).map IC.f.op) (↑s IB) = ↑((plusObj J P).map ID.f.op) (↑s I)
[PROOFSTEP]
exact s.condition IR
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
⊢ Presheaf.IsSheaf J (plusObj J P)
[PROOFSTEP]
rw [Presheaf.isSheaf_iff_multiequalizer]
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
⊢ ∀ (X : C) (S : Cover J X), IsIso (Cover.toMultiequalizer S (plusObj J P))
[PROOFSTEP]
intro X S
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
⊢ IsIso (Cover.toMultiequalizer S (plusObj J P))
[PROOFSTEP]
apply @isIso_of_reflects_iso _ _ _ _ _ _ _ (forget D) ?_
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
⊢ IsIso ((forget D).map (Cover.toMultiequalizer S (plusObj J P)))
[PROOFSTEP]
rw [isIso_iff_bijective]
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
⊢ Function.Bijective ((forget D).map (Cover.toMultiequalizer S (plusObj J P)))
[PROOFSTEP]
constructor
[GOAL]
case left
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
⊢ Function.Injective ((forget D).map (Cover.toMultiequalizer S (plusObj J P)))
[PROOFSTEP]
intro x y h
[GOAL]
case left
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x y : (forget D).obj ((plusObj J P).obj (op X))
h :
  (forget D).map (Cover.toMultiequalizer S (plusObj J P)) x = (forget D).map (Cover.toMultiequalizer S (plusObj J P)) y
⊢ x = y
[PROOFSTEP]
apply sep P S _ _
[GOAL]
case left
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x y : (forget D).obj ((plusObj J P).obj (op X))
h :
  (forget D).map (Cover.toMultiequalizer S (plusObj J P)) x = (forget D).map (Cover.toMultiequalizer S (plusObj J P)) y
⊢ ∀ (I : Cover.Arrow S), ↑((plusObj J P).map I.f.op) x = ↑((plusObj J P).map I.f.op) y
[PROOFSTEP]
intro I
[GOAL]
case left
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x y : (forget D).obj ((plusObj J P).obj (op X))
h :
  (forget D).map (Cover.toMultiequalizer S (plusObj J P)) x = (forget D).map (Cover.toMultiequalizer S (plusObj J P)) y
I : Cover.Arrow S
⊢ ↑((plusObj J P).map I.f.op) x = ↑((plusObj J P).map I.f.op) y
[PROOFSTEP]
apply_fun Meq.equiv _ _ at h 
[GOAL]
case left
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x y : (forget D).obj ((plusObj J P).obj (op X))
I : Cover.Arrow S
h :
  ↑(Meq.equiv (plusObj J P) S) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) x) =
    ↑(Meq.equiv (plusObj J P) S) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) y)
⊢ ↑((plusObj J P).map I.f.op) x = ↑((plusObj J P).map I.f.op) y
[PROOFSTEP]
apply_fun fun e => e I at h 
[GOAL]
case left
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x y : (forget D).obj ((plusObj J P).obj (op X))
I : Cover.Arrow S
h :
  ↑(↑(Meq.equiv (plusObj J P) S) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) x)) I =
    ↑(↑(Meq.equiv (plusObj J P) S) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) y)) I
⊢ ↑((plusObj J P).map I.f.op) x = ↑((plusObj J P).map I.f.op) y
[PROOFSTEP]
convert h
[GOAL]
case h.e'_2
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x y : (forget D).obj ((plusObj J P).obj (op X))
I : Cover.Arrow S
h :
  ↑(↑(Meq.equiv (plusObj J P) S) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) x)) I =
    ↑(↑(Meq.equiv (plusObj J P) S) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) y)) I
⊢ ↑((plusObj J P).map I.f.op) x =
    ↑(↑(Meq.equiv (plusObj J P) S) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) x)) I
[PROOFSTEP]
erw [Meq.equiv_apply, ← comp_apply, Multiequalizer.lift_ι]
[GOAL]
case h.e'_3
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x y : (forget D).obj ((plusObj J P).obj (op X))
I : Cover.Arrow S
h :
  ↑(↑(Meq.equiv (plusObj J P) S) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) x)) I =
    ↑(↑(Meq.equiv (plusObj J P) S) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) y)) I
⊢ ↑((plusObj J P).map I.f.op) y =
    ↑(↑(Meq.equiv (plusObj J P) S) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) y)) I
[PROOFSTEP]
erw [Meq.equiv_apply, ← comp_apply, Multiequalizer.lift_ι]
[GOAL]
case h.e'_2
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x y : (forget D).obj ((plusObj J P).obj (op X))
I : Cover.Arrow S
h :
  ↑(↑(Meq.equiv (plusObj J P) S) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) x)) I =
    ↑(↑(Meq.equiv (plusObj J P) S) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) y)) I
⊢ ↑((plusObj J P).map I.f.op) x = ↑((plusObj J P).map I.f.op) x
[PROOFSTEP]
rfl
[GOAL]
case h.e'_3
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x y : (forget D).obj ((plusObj J P).obj (op X))
I : Cover.Arrow S
h :
  ↑(↑(Meq.equiv (plusObj J P) S) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) x)) I =
    ↑(↑(Meq.equiv (plusObj J P) S) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) y)) I
⊢ ↑((plusObj J P).map I.f.op) y = ↑((plusObj J P).map I.f.op) y
[PROOFSTEP]
rfl
[GOAL]
case right
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
⊢ Function.Surjective ((forget D).map (Cover.toMultiequalizer S (plusObj J P)))
[PROOFSTEP]
rintro (x : (multiequalizer (S.index _) : D))
[GOAL]
case right
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x : (forget D).obj (multiequalizer (Cover.index S (plusObj J P)))
⊢ ∃ a, (forget D).map (Cover.toMultiequalizer S (plusObj J P)) a = x
[PROOFSTEP]
obtain ⟨t, ht⟩ := exists_of_sep P hsep X S (Meq.equiv _ _ x)
[GOAL]
case right.intro
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x : (forget D).obj (multiequalizer (Cover.index S (plusObj J P)))
t : (forget D).obj ((plusObj J P).obj (op X))
ht : Meq.mk S t = ↑(Meq.equiv (plusObj J P) S) x
⊢ ∃ a, (forget D).map (Cover.toMultiequalizer S (plusObj J P)) a = x
[PROOFSTEP]
use t
[GOAL]
case h
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x : (forget D).obj (multiequalizer (Cover.index S (plusObj J P)))
t : (forget D).obj ((plusObj J P).obj (op X))
ht : Meq.mk S t = ↑(Meq.equiv (plusObj J P) S) x
⊢ (forget D).map (Cover.toMultiequalizer S (plusObj J P)) t = x
[PROOFSTEP]
apply (Meq.equiv _ _).injective
[GOAL]
case h.a
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x : (forget D).obj (multiequalizer (Cover.index S (plusObj J P)))
t : (forget D).obj ((plusObj J P).obj (op X))
ht : Meq.mk S t = ↑(Meq.equiv (plusObj J P) S) x
⊢ ↑(Meq.equiv (plusObj J P) S) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) t) =
    ↑(Meq.equiv (plusObj J P) S) x
[PROOFSTEP]
rw [← ht]
[GOAL]
case h.a
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x : (forget D).obj (multiequalizer (Cover.index S (plusObj J P)))
t : (forget D).obj ((plusObj J P).obj (op X))
ht : Meq.mk S t = ↑(Meq.equiv (plusObj J P) S) x
⊢ ↑(Meq.equiv (plusObj J P) S) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) t) = Meq.mk S t
[PROOFSTEP]
ext i
[GOAL]
case h.a.h
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x : (forget D).obj (multiequalizer (Cover.index S (plusObj J P)))
t : (forget D).obj ((plusObj J P).obj (op X))
ht : Meq.mk S t = ↑(Meq.equiv (plusObj J P) S) x
i : Cover.Arrow S
⊢ ↑(↑(Meq.equiv (plusObj J P) S) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) t)) i = ↑(Meq.mk S t) i
[PROOFSTEP]
dsimp
[GOAL]
case h.a.h
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x : (forget D).obj (multiequalizer (Cover.index S (plusObj J P)))
t : (forget D).obj ((plusObj J P).obj (op X))
ht : Meq.mk S t = ↑(Meq.equiv (plusObj J P) S) x
i : Cover.Arrow S
⊢ ↑(Multiequalizer.ι (Cover.index S (plusObj J P)) i) ((forget D).map (Cover.toMultiequalizer S (plusObj J P)) t) =
    ↑(Meq.mk S t) i
[PROOFSTEP]
erw [← comp_apply]
[GOAL]
case h.a.h
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x : (forget D).obj (multiequalizer (Cover.index S (plusObj J P)))
t : (forget D).obj ((plusObj J P).obj (op X))
ht : Meq.mk S t = ↑(Meq.equiv (plusObj J P) S) x
i : Cover.Arrow S
⊢ ↑(Cover.toMultiequalizer S (plusObj J P) ≫ Multiequalizer.ι (Cover.index S (plusObj J P)) i) t = ↑(Meq.mk S t) i
[PROOFSTEP]
rw [Multiequalizer.lift_ι]
[GOAL]
case h.a.h
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
hsep :
  ∀ (X : C) (S : Cover J X) (x y : (forget D).obj (P.obj (op X))),
    (∀ (I : Cover.Arrow S), ↑(P.map I.f.op) x = ↑(P.map I.f.op) y) → x = y
X : C
S : Cover J X
x : (forget D).obj (multiequalizer (Cover.index S (plusObj J P)))
t : (forget D).obj ((plusObj J P).obj (op X))
ht : Meq.mk S t = ↑(Meq.equiv (plusObj J P) S) x
i : Cover.Arrow S
⊢ ↑((plusObj J P).map i.f.op) t = ↑(Meq.mk S t) i
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
⊢ Presheaf.IsSheaf J (plusObj J (plusObj J P))
[PROOFSTEP]
apply isSheaf_of_sep
[GOAL]
case hsep
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
⊢ ∀ (X : C) (S : Cover J X) (x y : (forget D).obj ((plusObj J P).obj (op X))),
    (∀ (I : Cover.Arrow S), ↑((plusObj J P).map I.f.op) x = ↑((plusObj J P).map I.f.op) y) → x = y
[PROOFSTEP]
intro X S x y
[GOAL]
case hsep
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
X : C
S : Cover J X
x y : (forget D).obj ((plusObj J P).obj (op X))
⊢ (∀ (I : Cover.Arrow S), ↑((plusObj J P).map I.f.op) x = ↑((plusObj J P).map I.f.op) y) → x = y
[PROOFSTEP]
apply sep
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
⊢ sheafifyMap J (𝟙 P) = 𝟙 (sheafify J P)
[PROOFSTEP]
dsimp [sheafifyMap, sheafify]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
⊢ plusMap J (plusMap J (𝟙 P)) = 𝟙 (plusObj J (plusObj J P))
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
⊢ sheafifyMap J (η ≫ γ) = sheafifyMap J η ≫ sheafifyMap J γ
[PROOFSTEP]
dsimp [sheafifyMap, sheafify]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
⊢ plusMap J (plusMap J (η ≫ γ)) = plusMap J (plusMap J η) ≫ plusMap J (plusMap J γ)
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
⊢ η ≫ toSheafify J Q = toSheafify J P ≫ sheafifyMap J η
[PROOFSTEP]
dsimp [sheafifyMap, sheafify, toSheafify]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
⊢ η ≫ toPlus J Q ≫ plusMap J (toPlus J Q) = (toPlus J P ≫ plusMap J (toPlus J P)) ≫ plusMap J (plusMap J η)
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
⊢ IsIso (toSheafify J P)
[PROOFSTEP]
dsimp [toSheafify]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
⊢ IsIso (toPlus J P ≫ plusMap J (toPlus J P))
[PROOFSTEP]
haveI := isIso_toPlus_of_isSheaf J P hP
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
this : IsIso (toPlus J P)
⊢ IsIso (toPlus J P ≫ plusMap J (toPlus J P))
[PROOFSTEP]
change (IsIso (toPlus J P ≫ (J.plusFunctor D).map (toPlus J P)))
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
this : IsIso (toPlus J P)
⊢ IsIso (toPlus J P ≫ (plusFunctor J D).map (toPlus J P))
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
hQ : Presheaf.IsSheaf J Q
⊢ toSheafify J P ≫ sheafifyLift J η hQ = η
[PROOFSTEP]
dsimp only [sheafifyLift, toSheafify]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
hQ : Presheaf.IsSheaf J Q
⊢ (toPlus J P ≫ plusMap J (toPlus J P)) ≫ plusLift J (plusLift J η hQ) hQ = η
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
hQ : Presheaf.IsSheaf J Q
γ : sheafify J P ⟶ Q
⊢ toSheafify J P ≫ γ = η → γ = sheafifyLift J η hQ
[PROOFSTEP]
intro h
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
hQ : Presheaf.IsSheaf J Q
γ : sheafify J P ⟶ Q
h : toSheafify J P ≫ γ = η
⊢ γ = sheafifyLift J η hQ
[PROOFSTEP]
apply plusLift_unique
[GOAL]
case hγ
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
hQ : Presheaf.IsSheaf J Q
γ : sheafify J P ⟶ Q
h : toSheafify J P ≫ γ = η
⊢ toPlus J (plusObj J P) ≫ γ = plusLift J η hQ
[PROOFSTEP]
apply plusLift_unique
[GOAL]
case hγ.hγ
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
hQ : Presheaf.IsSheaf J Q
γ : sheafify J P ⟶ Q
h : toSheafify J P ≫ γ = η
⊢ toPlus J P ≫ toPlus J (plusObj J P) ≫ γ = η
[PROOFSTEP]
rw [← Category.assoc, ← plusMap_toPlus]
[GOAL]
case hγ.hγ
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
hQ : Presheaf.IsSheaf J Q
γ : sheafify J P ⟶ Q
h : toSheafify J P ≫ γ = η
⊢ (toPlus J P ≫ plusMap J (toPlus J P)) ≫ γ = η
[PROOFSTEP]
exact h
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
⊢ (isoSheafify J hP).inv = sheafifyLift J (𝟙 P) hP
[PROOFSTEP]
apply J.sheafifyLift_unique
[GOAL]
case a
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
⊢ toSheafify J P ≫ (isoSheafify J hP).inv = 𝟙 P
[PROOFSTEP]
simp [Iso.comp_inv_eq]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η γ : sheafify J P ⟶ Q
hQ : Presheaf.IsSheaf J Q
h : toSheafify J P ≫ η = toSheafify J P ≫ γ
⊢ η = γ
[PROOFSTEP]
apply J.plus_hom_ext _ _ hQ
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η γ : sheafify J P ⟶ Q
hQ : Presheaf.IsSheaf J Q
h : toSheafify J P ≫ η = toSheafify J P ≫ γ
⊢ toPlus J (plusObj J P) ≫ η = toPlus J (plusObj J P) ≫ γ
[PROOFSTEP]
apply J.plus_hom_ext _ _ hQ
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η γ : sheafify J P ⟶ Q
hQ : Presheaf.IsSheaf J Q
h : toSheafify J P ≫ η = toSheafify J P ≫ γ
⊢ toPlus J P ≫ toPlus J (plusObj J P) ≫ η = toPlus J P ≫ toPlus J (plusObj J P) ≫ γ
[PROOFSTEP]
rw [← Category.assoc, ← Category.assoc, ← plusMap_toPlus]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η γ : sheafify J P ⟶ Q
hQ : Presheaf.IsSheaf J Q
h : toSheafify J P ≫ η = toSheafify J P ≫ γ
⊢ (toPlus J P ≫ plusMap J (toPlus J P)) ≫ η = (toPlus J P ≫ plusMap J (toPlus J P)) ≫ γ
[PROOFSTEP]
exact h
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ sheafifyMap J η ≫ sheafifyLift J γ hR = sheafifyLift J (η ≫ γ) hR
[PROOFSTEP]
apply J.sheafifyLift_unique
[GOAL]
case a
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ toSheafify J P ≫ sheafifyMap J η ≫ sheafifyLift J γ hR = η ≫ γ
[PROOFSTEP]
rw [← Category.assoc, ← J.toSheafify_naturality, Category.assoc, toSheafify_sheafifyLift]
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁷ : Category.{max v u, w} D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : PreservesLimits (forget D)
inst✝⁴ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝³ : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝² : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝¹ : ReflectsIsomorphisms (forget D)
inst✝ : Preadditive D
F G : Cᵒᵖ ⥤ D
⊢ (presheafToSheaf J D).map 0 = 0
[PROOFSTEP]
ext : 3
[GOAL]
case h.w.h
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁷ : Category.{max v u, w} D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : PreservesLimits (forget D)
inst✝⁴ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝³ : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝² : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝¹ : ReflectsIsomorphisms (forget D)
inst✝ : Preadditive D
F G : Cᵒᵖ ⥤ D
x✝ : Cᵒᵖ
⊢ NatTrans.app ((presheafToSheaf J D).map 0).val x✝ = NatTrans.app 0.val x✝
[PROOFSTEP]
refine' colimit.hom_ext (fun j => _)
[GOAL]
case h.w.h
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁷ : Category.{max v u, w} D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : PreservesLimits (forget D)
inst✝⁴ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝³ : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝² : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝¹ : ReflectsIsomorphisms (forget D)
inst✝ : Preadditive D
F G : Cᵒᵖ ⥤ D
x✝ : Cᵒᵖ
j : (GrothendieckTopology.Cover J x✝.unop)ᵒᵖ
⊢ colimit.ι (GrothendieckTopology.diagram J (GrothendieckTopology.plusObj J F) x✝.unop) j ≫
      NatTrans.app ((presheafToSheaf J D).map 0).val x✝ =
    colimit.ι (GrothendieckTopology.diagram J (GrothendieckTopology.plusObj J F) x✝.unop) j ≫ NatTrans.app 0.val x✝
[PROOFSTEP]
erw [colimit.ι_map, comp_zero, J.plusMap_zero, J.diagramNatTrans_zero, zero_comp]
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
⊢ ∀ {X' X : Cᵒᵖ ⥤ D} {Y : Sheaf J D} (f : X' ⟶ X) (g : X ⟶ (sheafToPresheaf J D).obj Y),
    ↑((fun P Q =>
                { toFun := fun e => GrothendieckTopology.toSheafify J P ≫ e.val,
                  invFun := fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) },
                  left_inv :=
                    (_ :
                      ∀ (e : (presheafToSheaf J D).obj P ⟶ Q),
                        (fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) })
                            ((fun e => GrothendieckTopology.toSheafify J P ≫ e.val) e) =
                          e),
                  right_inv :=
                    (_ :
                      ∀ (e : P ⟶ (sheafToPresheaf J D).obj Q),
                        GrothendieckTopology.toSheafify J P ≫
                            GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) =
                          e) })
              X' Y).symm
        (f ≫ g) =
      (presheafToSheaf J D).map f ≫
        ↑((fun P Q =>
                  { toFun := fun e => GrothendieckTopology.toSheafify J P ≫ e.val,
                    invFun := fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) },
                    left_inv :=
                      (_ :
                        ∀ (e : (presheafToSheaf J D).obj P ⟶ Q),
                          (fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) })
                              ((fun e => GrothendieckTopology.toSheafify J P ≫ e.val) e) =
                            e),
                    right_inv :=
                      (_ :
                        ∀ (e : P ⟶ (sheafToPresheaf J D).obj Q),
                          GrothendieckTopology.toSheafify J P ≫
                              GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) =
                            e) })
                X Y).symm
          g
[PROOFSTEP]
intro P Q R η γ
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P Q : Cᵒᵖ ⥤ D
R : Sheaf J D
η : P ⟶ Q
γ : Q ⟶ (sheafToPresheaf J D).obj R
⊢ ↑((fun P Q =>
              { toFun := fun e => GrothendieckTopology.toSheafify J P ≫ e.val,
                invFun := fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) },
                left_inv :=
                  (_ :
                    ∀ (e : (presheafToSheaf J D).obj P ⟶ Q),
                      (fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) })
                          ((fun e => GrothendieckTopology.toSheafify J P ≫ e.val) e) =
                        e),
                right_inv :=
                  (_ :
                    ∀ (e : P ⟶ (sheafToPresheaf J D).obj Q),
                      GrothendieckTopology.toSheafify J P ≫
                          GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) =
                        e) })
            P R).symm
      (η ≫ γ) =
    (presheafToSheaf J D).map η ≫
      ↑((fun P Q =>
                { toFun := fun e => GrothendieckTopology.toSheafify J P ≫ e.val,
                  invFun := fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) },
                  left_inv :=
                    (_ :
                      ∀ (e : (presheafToSheaf J D).obj P ⟶ Q),
                        (fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) })
                            ((fun e => GrothendieckTopology.toSheafify J P ≫ e.val) e) =
                          e),
                  right_inv :=
                    (_ :
                      ∀ (e : P ⟶ (sheafToPresheaf J D).obj Q),
                        GrothendieckTopology.toSheafify J P ≫
                            GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) =
                          e) })
              Q R).symm
        γ
[PROOFSTEP]
ext1
[GOAL]
case h
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P Q : Cᵒᵖ ⥤ D
R : Sheaf J D
η : P ⟶ Q
γ : Q ⟶ (sheafToPresheaf J D).obj R
⊢ (↑((fun P Q =>
                { toFun := fun e => GrothendieckTopology.toSheafify J P ≫ e.val,
                  invFun := fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) },
                  left_inv :=
                    (_ :
                      ∀ (e : (presheafToSheaf J D).obj P ⟶ Q),
                        (fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) })
                            ((fun e => GrothendieckTopology.toSheafify J P ≫ e.val) e) =
                          e),
                  right_inv :=
                    (_ :
                      ∀ (e : P ⟶ (sheafToPresheaf J D).obj Q),
                        GrothendieckTopology.toSheafify J P ≫
                            GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) =
                          e) })
              P R).symm
        (η ≫ γ)).val =
    ((presheafToSheaf J D).map η ≫
        ↑((fun P Q =>
                  { toFun := fun e => GrothendieckTopology.toSheafify J P ≫ e.val,
                    invFun := fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) },
                    left_inv :=
                      (_ :
                        ∀ (e : (presheafToSheaf J D).obj P ⟶ Q),
                          (fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) })
                              ((fun e => GrothendieckTopology.toSheafify J P ≫ e.val) e) =
                            e),
                    right_inv :=
                      (_ :
                        ∀ (e : P ⟶ (sheafToPresheaf J D).obj Q),
                          GrothendieckTopology.toSheafify J P ≫
                              GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) =
                            e) })
                Q R).symm
          γ).val
[PROOFSTEP]
dsimp
[GOAL]
case h
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P Q : Cᵒᵖ ⥤ D
R : Sheaf J D
η : P ⟶ Q
γ : Q ⟶ (sheafToPresheaf J D).obj R
⊢ GrothendieckTopology.sheafifyLift J (η ≫ γ) (_ : Presheaf.IsSheaf J R.val) =
    GrothendieckTopology.sheafifyMap J η ≫ GrothendieckTopology.sheafifyLift J γ (_ : Presheaf.IsSheaf J R.val)
[PROOFSTEP]
symm
[GOAL]
case h
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P Q : Cᵒᵖ ⥤ D
R : Sheaf J D
η : P ⟶ Q
γ : Q ⟶ (sheafToPresheaf J D).obj R
⊢ GrothendieckTopology.sheafifyMap J η ≫ GrothendieckTopology.sheafifyLift J γ (_ : Presheaf.IsSheaf J R.val) =
    GrothendieckTopology.sheafifyLift J (η ≫ γ) (_ : Presheaf.IsSheaf J R.val)
[PROOFSTEP]
apply J.sheafifyMap_sheafifyLift
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
X✝ : Cᵒᵖ ⥤ D
Y✝ Y'✝ : Sheaf J D
η : (presheafToSheaf J D).obj X✝ ⟶ Y✝
γ : Y✝ ⟶ Y'✝
⊢ ↑((fun P Q =>
            { toFun := fun e => GrothendieckTopology.toSheafify J P ≫ e.val,
              invFun := fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) },
              left_inv :=
                (_ :
                  ∀ (e : (presheafToSheaf J D).obj P ⟶ Q),
                    (fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) })
                        ((fun e => GrothendieckTopology.toSheafify J P ≫ e.val) e) =
                      e),
              right_inv :=
                (_ :
                  ∀ (e : P ⟶ (sheafToPresheaf J D).obj Q),
                    GrothendieckTopology.toSheafify J P ≫
                        GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) =
                      e) })
          X✝ Y'✝)
      (η ≫ γ) =
    ↑((fun P Q =>
              { toFun := fun e => GrothendieckTopology.toSheafify J P ≫ e.val,
                invFun := fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) },
                left_inv :=
                  (_ :
                    ∀ (e : (presheafToSheaf J D).obj P ⟶ Q),
                      (fun e => { val := GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) })
                          ((fun e => GrothendieckTopology.toSheafify J P ≫ e.val) e) =
                        e),
                right_inv :=
                  (_ :
                    ∀ (e : P ⟶ (sheafToPresheaf J D).obj Q),
                      GrothendieckTopology.toSheafify J P ≫
                          GrothendieckTopology.sheafifyLift J e (_ : Presheaf.IsSheaf J Q.val) =
                        e) })
            X✝ Y✝)
        η ≫
      (sheafToPresheaf J D).map γ
[PROOFSTEP]
dsimp
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
X✝ : Cᵒᵖ ⥤ D
Y✝ Y'✝ : Sheaf J D
η : (presheafToSheaf J D).obj X✝ ⟶ Y✝
γ : Y✝ ⟶ Y'✝
⊢ GrothendieckTopology.toSheafify J X✝ ≫ η.val ≫ γ.val = (GrothendieckTopology.toSheafify J X✝ ≫ η.val) ≫ γ.val
[PROOFSTEP]
rw [Category.assoc]
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
F G : Sheaf J D
f : F ⟶ G
m : Mono f
⊢ Mono f.val
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
F G : Sheaf J D
f : F ⟶ G
m : Mono f.val
⊢ Mono f
[PROOFSTEP]
exact Sheaf.Hom.mono_of_presheaf_mono J D f
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Sheaf J D
⊢ { val := (GrothendieckTopology.isoSheafify J (_ : Presheaf.IsSheaf J P.val)).hom } ≫
      { val := (GrothendieckTopology.isoSheafify J (_ : Presheaf.IsSheaf J P.val)).inv } =
    𝟙 P
[PROOFSTEP]
ext1
[GOAL]
case h
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Sheaf J D
⊢ ({ val := (GrothendieckTopology.isoSheafify J (_ : Presheaf.IsSheaf J P.val)).hom } ≫
        { val := (GrothendieckTopology.isoSheafify J (_ : Presheaf.IsSheaf J P.val)).inv }).val =
    (𝟙 P).val
[PROOFSTEP]
apply (J.isoSheafify P.2).hom_inv_id
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Sheaf J D
⊢ { val := (GrothendieckTopology.isoSheafify J (_ : Presheaf.IsSheaf J P.val)).inv } ≫
      { val := (GrothendieckTopology.isoSheafify J (_ : Presheaf.IsSheaf J P.val)).hom } =
    𝟙 ((presheafToSheaf J D).obj P.val)
[PROOFSTEP]
ext1
[GOAL]
case h
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Sheaf J D
⊢ ({ val := (GrothendieckTopology.isoSheafify J (_ : Presheaf.IsSheaf J P.val)).inv } ≫
        { val := (GrothendieckTopology.isoSheafify J (_ : Presheaf.IsSheaf J P.val)).hom }).val =
    (𝟙 ((presheafToSheaf J D).obj P.val)).val
[PROOFSTEP]
apply (J.isoSheafify P.2).inv_hom_id
