awhecmu/canonical-drafter-extract-mathlib huggingface dataset:
-- Module: Mathlib.CategoryTheory.Sites.ConcreteSheafification
Goal:
C : Type u
inst : Category.{v, u} C
J : GrothendieckTopology.{v, u} C
D : Type w
inst_1 : Category.{w', w} D
FD : D → D → Type u_1
CD : D → Type t
inst_2 : (X Y : D) → FunLike.{u_1 + 1, t + 1, t + 1} (FD X Y) (CD X) (CD Y)
instCC : ConcreteCategory.{t, w', w, u_1} D FD (CC := CD)
inst_3 : ∀ {X : C} (S : J.Cover X), PreservesLimitsOfShape (WalkingMulticospan S.shape) (forget D (FC := FD) (CC := CD))
inst_4 : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst_5 : ∀ (P : Functor.{v, w', u, w} Cᵒᵖ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Functor.{v, w', u, w} Cᵒᵖ D
S : J.Cover X
x : Meq (FD := FD) (CD := CD) P S
I : S.Arrow
delta :
  Eq (α := CD (colimit (J := (J.Cover I.Y)ᵒᵖ) (J.diagram P I.Y)))
    ((ConcreteCategory.hom (FC := FD) (CC := CD)
            (CategoryStruct.comp (Y :=
              multiequalizer (J := Cover.shape.{v, u} (C := C) (X := I.Y) (J := J) ⊤) (Cover.index ⊤ P))
              (Multiequalizer.lift (Cover.index ⊤ P) (P.obj (op I.Y))
                (fun (I_1 : (Cover.shape.{v, u} (C := C) (X := I.Y) (J := J) ⊤).L) ↦ P.map I_1.f.op) ⋯)
              (colimit.ι (J.diagram P I.Y) (op ⊤))) :
          (a : CD (P.obj (op I.Y))) → CD (colimit (J.diagram P I.Y)))
        ((↑x : (I : S.Arrow) → ToType (P.obj (op I.Y))) I) :
      CD (colimit (J := (J.Cover I.Y)ᵒᵖ) (J.diagram P I.Y)))
    ((ConcreteCategory.hom (FC := FD) (CC := CD)
            (CategoryStruct.comp (Y := colimit ((J.pullback I.f.op.unop).op ⋙ J.diagram P I.Y))
              (colimMap (J.diagramPullback P I.f.op.unop))
              (colimit.pre (J.diagram P I.Y) (J.pullback I.f.op.unop).op)) :
          (a : CD (colimit (J.diagram P X))) → CD (colimit (J.diagram P I.Y)))
        (mk (FD := FD) (CD := CD) x) :
      CD (colimit (J := (J.Cover I.Y)ᵒᵖ) (J.diagram P I.Y)))
⊢ Eq (α := CD (colimit (J := (J.Cover I.Y)ᵒᵖ) (J.diagram P I.Y)))
    ((ConcreteCategory.hom (FC := FD) (CC := CD)
            (CategoryStruct.comp (Y :=
              multiequalizer (J := Cover.shape.{v, u} (C := C) (X := I.Y) (J := J) ⊤) (Cover.index ⊤ P))
              (Cover.toMultiequalizer ⊤ P) (colimit.ι (J.diagram P I.Y) (op ⊤))) :
          (a : CD (P.obj (op I.Y))) → CD (colimit (J.diagram P I.Y)))
        ((↑x : (I : S.Arrow) → ToType (P.obj (op I.Y))) I) :
      CD (colimit (J := (J.Cover I.Y)ᵒᵖ) (J.diagram P I.Y)))
    ((ConcreteCategory.hom (FC := FD) (CC := CD)
            (CategoryStruct.comp (Y := colimit ((J.pullback I.f.op.unop).op ⋙ J.diagram P I.Y))
              (colimMap (J.diagramPullback P I.f.op.unop))
              (colimit.pre (J.diagram P I.Y) (J.pullback I.f.op.unop).op)) :
          (a : CD (colimit (J.diagram P X))) → CD (colimit (J.diagram P I.Y)))
        (mk (FD := FD) (CD := CD) x) :
      CD (colimit (J := (J.Cover I.Y)ᵒᵖ) (J.diagram P I.Y)))

Tactic:
delta Cover.toMultiequalizer

Premises used: CategoryTheory.GrothendieckTopology.Cover.toMultiequalizer
-- Module: Mathlib.CategoryTheory.Sites.ConcreteSheafification
Goal:
C : Type u
inst : Category.{v, u} C
J : GrothendieckTopology.{v, u} C
D : Type w
inst_1 : Category.{w', w} D
FD : D → D → Type u_1
CD : D → Type t
inst_2 : (X Y : D) → FunLike.{u_1 + 1, t + 1, t + 1} (FD X Y) (CD X) (CD Y)
instCC : ConcreteCategory.{t, w', w, u_1} D FD (CC := CD)
inst_3 : ∀ {X : C} (S : J.Cover X), PreservesLimitsOfShape (WalkingMulticospan S.shape) (forget D (FC := FD) (CC := CD))
inst_4 : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst_5 : ∀ (P : Functor.{v, w', u, w} Cᵒᵖ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Functor.{v, w', u, w} Cᵒᵖ D
S : J.Cover X
x : Meq (FD := FD) (CD := CD) P S
I : S.Arrow
e : (J.pullback I.f).obj (unop (op S)) ⟶ ⊤ := homOfLE ⋯
i : (unop (op ((J.pullback I.f).obj (unop (op S))))).shape.L
h :
  (ConcreteCategory.hom (FC := FD) (CC := CD) (P.map (Cover.Arrow.map i e).f.op) :
        (a : CD (P.obj (op I.Y))) → CD (P.obj (op i.Y)))
      ((↑x : (I : S.Arrow) → ToType (P.obj (op I.Y))) I) =
    (↑x : (I : S.Arrow) → ToType (P.obj (op I.Y))) (Cover.Arrow.base i)
⊢ Eq (α := CD (P.obj (op i.Y)))
    ((ConcreteCategory.hom (FC := FD) (CC := CD) (P.map (Cover.Arrow.map i e).f.op) :
          (a : CD (P.obj (op I.Y))) → CD (P.obj (op i.Y)))
        ((↑x : (I : S.Arrow) → ToType (P.obj (op I.Y))) I) :
      CD (P.obj (op i.Y)))
    (((@ConcreteCategory.hom.{t, w', w, u_1} _ inst_1 FD CD _ _ _ _
              (Multiequalizer.ι (S.index P) (Cover.Arrow.base i)) :
            FD (multiequalizer (S.index P)) (P.obj (op i.Y))) :
          (a : CD (multiequalizer (S.index P))) → CD (P.obj (op i.Y)))
        ((Equiv.symm (Meq.equiv (FD := FD) (CD := CD) P S) : (a : Meq P S) → ToType (multiequalizer (S.index P))) x :
          ToType.{t, w', w, u_1} (FC := FD) (CC := CD) (multiequalizer (S.index P))) :
      CD (P.obj (op i.Y)))

Tactic:
rw [dsimp% Meq.equiv_symm_eq_apply x i.base]

Premises used: CategoryTheory.GrothendieckTopology.Cover.Arrow.base, CategoryTheory.Meq.equiv_symm_eq_apply
-- Module: Mathlib.CategoryTheory.Sites.ConcreteSheafification
Goal:
C : Type u
inst : Category.{v, u} C
J : GrothendieckTopology.{v, u} C
D : Type w
inst_1 : Category.{w', w} D
FD : D → D → Type u_1
CD : D → Type t
inst_2 : (X Y : D) → FunLike.{u_1 + 1, t + 1, t + 1} (FD X Y) (CD X) (CD Y)
instCC : ConcreteCategory.{t, w', w, u_1} D FD (CC := CD)
inst_3 : ∀ {X : C} (S : J.Cover X), PreservesLimitsOfShape (WalkingMulticospan S.shape) (forget D (FC := FD) (CC := CD))
inst_4 : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst_5 : ∀ (P : Functor.{v, w', u, w} Cᵒᵖ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Functor.{v, w', u, w} Cᵒᵖ D
S : J.Cover X
x : Meq (FD := FD) (CD := CD) P S
I : S.Arrow
e : (J.pullback I.f).obj (unop (op S)) ⟶ ⊤ := homOfLE ⋯
i : (unop (op ((J.pullback I.f).obj (unop (op S))))).shape.L
⊢ (ConcreteCategory.hom (FC := FD) (CC := CD) (P.map (Cover.Arrow.map i e).f.op) :
        (a : CD (P.obj (op I.Y))) → CD (P.obj (op i.Y)))
      ((↑x : (I : S.Arrow) → ToType (P.obj (op I.Y))) I) =
    (↑x : (I : S.Arrow) → ToType (P.obj (op I.Y))) (Cover.Arrow.base i)

Tactic:
simpa using (x.condition (Cover.Relation.mk' (I.precompRelation i.f))).symm

Premises used: CategoryTheory.GrothendieckTopology.Cover.Relation.mk', CategoryTheory.GrothendieckTopology.Cover.Arrow.f, Eq.symm, CategoryTheory.Meq.condition, CategoryTheory.GrothendieckTopology.Cover.Arrow.precompRelation
-- Module: Mathlib.CategoryTheory.Sites.ConcreteSheafification
Goal:
C : Type u
inst : Category.{v, u} C
J : GrothendieckTopology.{v, u} C
D : Type w
inst_1 : Category.{w', w} D
FD : D → D → Type u_1
CD : D → Type t
inst_2 : (X Y : D) → FunLike.{u_1 + 1, t + 1, t + 1} (FD X Y) (CD X) (CD Y)
instCC : ConcreteCategory.{t, w', w, u_1} D FD (CC := CD)
inst_3 : ∀ {X : C} (S : J.Cover X), PreservesLimitsOfShape (WalkingMulticospan S.shape) (forget D (FC := FD) (CC := CD))
inst_4 : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst_5 : ∀ (P : Functor.{v, w', u, w} Cᵒᵖ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Functor.{v, w', u, w} Cᵒᵖ D
x : ToType.{t, w', w, u_1} (FC := FD) (CC := CD) (P.obj (op X))
⊢ Eq (α := CD ((J.plusObj P).obj (op X)))
    ((ConcreteCategory.hom (FC := FD) (CC := CD) (NatTrans.app (J.toPlus P) (op X)) :
          (a : CD (P.obj (op X))) → CD ((J.plusObj P).obj (op X)))
        x :
      CD ((J.plusObj P).obj (op X)))
    (mk (FD := FD) (CD := CD) (S := ⊤) (Meq.mk (FD := FD) (CD := CD) ⊤ x) :
      ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.plusObj P).obj (op X)))

Tactic:
toPlus_mk ⊤ x

Premises used: CategoryTheory.GrothendieckTopology.Plus.toPlus_mk, Top.top
-- Module: Mathlib.CategoryTheory.Sites.ConcreteSheafification
Goal:
C : Type u
inst : Category.{v, u} C
J : GrothendieckTopology.{v, u} C
D : Type w
inst_1 : Category.{w', w} D
FD : D → D → Type u_1
CD : D → Type t
inst_2 : (X Y : D) → FunLike.{u_1 + 1, t + 1, t + 1} (FD X Y) (CD X) (CD Y)
instCC : ConcreteCategory.{t, w', w, u_1} D FD (CC := CD)
inst_3 : ∀ {X : C} (S : J.Cover X), PreservesLimitsOfShape (WalkingMulticospan S.shape) (forget D (FC := FD) (CC := CD))
inst_4 : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst_5 : ∀ (P : Functor.{v, w', u, w} Cᵒᵖ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst_6 : ∀ (X : C), PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D (FC := FD) (CC := CD))
X : C
P : Functor.{v, w', u, w} Cᵒᵖ D
x : ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.plusObj P).obj (op X))
obtain :
  ∀ (S : (J.Cover X)ᵒᵖ) (y : ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.diagram P X).obj S))
    (h :
      (ConcreteCategory.hom (FC := FD) (CC := CD) (colimit.ι (J.diagram P X) S) :
            (a : CD ((J.diagram P X).obj S)) → CD (colimit (J.diagram P X)))
          y =
        x),
    ∃ (S : J.Cover X) (y : Meq (FD := FD) (CD := CD) P S), x = mk (FD := FD) (CD := CD) y
⊢ ∃ (S : J.Cover X) (y : Meq (FD := FD) (CD := CD) P S), x = mk (FD := FD) (CD := CD) y

Tactic:
obtain ⟨S, y, h⟩ := Concrete.colimit_exists_rep (J.diagram P X) x

Premises used: CategoryTheory.Limits.Concrete.colimit_exists_rep, CategoryTheory.GrothendieckTopology.diagram
-- Module: Mathlib.CategoryTheory.Sites.ConcreteSheafification
Goal:
C : Type u
inst : Category.{v, u} C
J : GrothendieckTopology.{v, u} C
D : Type w
inst_1 : Category.{w', w} D
FD : D → D → Type u_1
CD : D → Type t
inst_2 : (X Y : D) → FunLike.{u_1 + 1, t + 1, t + 1} (FD X Y) (CD X) (CD Y)
instCC : ConcreteCategory.{t, w', w, u_1} D FD (CC := CD)
inst_3 : ∀ {X : C} (S : J.Cover X), PreservesLimitsOfShape (WalkingMulticospan S.shape) (forget D (FC := FD) (CC := CD))
inst_4 : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst_5 : ∀ (P : Functor.{v, w', u, w} Cᵒᵖ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst_6 : ∀ (X : C), PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D (FC := FD) (CC := CD))
X : C
P : Functor.{v, w', u, w} Cᵒᵖ D
x : ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.plusObj P).obj (op X))
S : (J.Cover X)ᵒᵖ
y : ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.diagram P X).obj S)
h :
  (ConcreteCategory.hom (FC := FD) (CC := CD) (colimit.ι (J.diagram P X) S) :
        (a : CD ((J.diagram P X).obj S)) → CD (colimit (J.diagram P X)))
      y =
    x
h₁ :
  x =
    mk (FD := FD) (CD := CD) (S := unop S)
      ((Meq.equiv (FD := FD) (CD := CD) P (unop S) : (a : ToType (multiequalizer ((unop S).index P))) → Meq P (unop S))
        y)
⊢ ∃ (S : J.Cover X) (y : Meq (FD := FD) (CD := CD) P S), x = mk (FD := FD) (CD := CD) y

Tactic:
use S.unop, Meq.equiv _ _ y

Premises used: CategoryTheory.Meq.equiv, DFunLike.coe, Opposite.unop
-- Module: Mathlib.CategoryTheory.Sites.ConcreteSheafification
Goal:
C : Type u
inst : Category.{v, u} C
J : GrothendieckTopology.{v, u} C
D : Type w
inst_1 : Category.{w', w} D
FD : D → D → Type u_1
CD : D → Type t
inst_2 : (X Y : D) → FunLike.{u_1 + 1, t + 1, t + 1} (FD X Y) (CD X) (CD Y)
instCC : ConcreteCategory.{t, w', w, u_1} D FD (CC := CD)
inst_3 : ∀ {X : C} (S : J.Cover X), PreservesLimitsOfShape (WalkingMulticospan S.shape) (forget D (FC := FD) (CC := CD))
inst_4 : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst_5 : ∀ (P : Functor.{v, w', u, w} Cᵒᵖ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst_6 : ∀ (X : C), PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D (FC := FD) (CC := CD))
X : C
P : Functor.{v, w', u, w} Cᵒᵖ D
x : ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.plusObj P).obj (op X))
S : (J.Cover X)ᵒᵖ
y : ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.diagram P X).obj S)
h :
  (ConcreteCategory.hom (FC := FD) (CC := CD) (colimit.ι (J.diagram P X) S) :
        (a : CD ((J.diagram P X).obj S)) → CD (colimit (J.diagram P X)))
      y =
    x
h₁ :
  Eq (α := ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.plusObj P).obj (op X)))
    ((ConcreteCategory.hom (FC := FD) (CC := CD) (colimit.ι (J.diagram P X) S) :
          (a : CD ((J.diagram P X).obj S)) → CD (colimit (J.diagram P X)))
        y :
      CD (colimit (J.diagram P X)))
    (mk (FD := FD) (CD := CD) (S := unop S)
        ((Meq.equiv (FD := FD) (CD := CD) P (unop S) :
            (a : ToType (multiequalizer ((unop S).index P))) → Meq P (unop S))
          y) :
      ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.plusObj P).obj (op X)))
⊢ x =
    mk (FD := FD) (CD := CD) (S := unop S)
      ((Meq.equiv (FD := FD) (CD := CD) P (unop S) : (a : ToType (multiequalizer ((unop S).index P))) → Meq P (unop S))
        y)

Tactic:
rw [← h]
-- Module: Mathlib.CategoryTheory.Sites.ConcreteSheafification
Goal:
C : Type u
inst : Category.{v, u} C
J : GrothendieckTopology.{v, u} C
D : Type w
inst_1 : Category.{w', w} D
FD : D → D → Type u_1
CD : D → Type t
inst_2 : (X Y : D) → FunLike.{u_1 + 1, t + 1, t + 1} (FD X Y) (CD X) (CD Y)
instCC : ConcreteCategory.{t, w', w, u_1} D FD (CC := CD)
inst_3 : ∀ {X : C} (S : J.Cover X), PreservesLimitsOfShape (WalkingMulticospan S.shape) (forget D (FC := FD) (CC := CD))
inst_4 : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst_5 : ∀ (P : Functor.{v, w', u, w} Cᵒᵖ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst_6 : ∀ (X : C), PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D (FC := FD) (CC := CD))
X : C
P : Functor.{v, w', u, w} Cᵒᵖ D
x : ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.plusObj P).obj (op X))
S : (J.Cover X)ᵒᵖ
y : ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.diagram P X).obj S)
h :
  (ConcreteCategory.hom (FC := FD) (CC := CD) (colimit.ι (J.diagram P X) S) :
        (a : CD ((J.diagram P X).obj S)) → CD (colimit (J.diagram P X)))
      y =
    x
h₁ :
  Eq (α := ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.plusObj P).obj (op X)))
    ((ConcreteCategory.hom (FC := FD) (CC := CD) (colimit.ι (J.diagram P X) S) :
          (a : CD (multiequalizer ((unop S).index P))) → CD (colimit (J.diagram P X)))
        y :
      CD (colimit (J.diagram P X)))
    ((ConcreteCategory.hom (FC := FD) (CC := CD) (colimit.ι (J.diagram P X) S) :
          (a : CD (multiequalizer ((unop S).index P))) → CD (colimit (J.diagram P X)))
        ((Equiv.symm (Meq.equiv (FD := FD) (CD := CD) P (unop S)) :
              (a : Meq P (unop S)) → ToType (multiequalizer ((unop S).index P)))
            ((Meq.equiv (FD := FD) (CD := CD) P (unop S) :
                (a : ToType (multiequalizer ((unop S).index P))) → Meq P (unop S))
              y) :
          ToType.{t, w', w, u_1} (FC := FD) (CC := CD) (multiequalizer ((unop S).index P))) :
      CD (colimit (J.diagram P X)))
⊢ Eq (α := ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.plusObj P).obj (op X)))
    ((ConcreteCategory.hom (FC := FD) (CC := CD) (colimit.ι (J.diagram P X) S) :
          (a : CD ((J.diagram P X).obj S)) → CD (colimit (J.diagram P X)))
        y :
      CD (colimit (J.diagram P X)))
    (mk (FD := FD) (CD := CD) (S := unop S)
        ((Meq.equiv (FD := FD) (CD := CD) P (unop S) :
            (a : ToType (multiequalizer ((unop S).index P))) → Meq P (unop S))
          y) :
      ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.plusObj P).obj (op X)))

Tactic:
dsimp [mk]

Premises used: CategoryTheory.GrothendieckTopology.Plus.mk
-- Module: Mathlib.CategoryTheory.Sites.ConcreteSheafification
Goal:
C : Type u
inst : Category.{v, u} C
J : GrothendieckTopology.{v, u} C
D : Type w
inst_1 : Category.{w', w} D
FD : D → D → Type u_1
CD : D → Type t
inst_2 : (X Y : D) → FunLike.{u_1 + 1, t + 1, t + 1} (FD X Y) (CD X) (CD Y)
instCC : ConcreteCategory.{t, w', w, u_1} D FD (CC := CD)
inst_3 : ∀ {X : C} (S : J.Cover X), PreservesLimitsOfShape (WalkingMulticospan S.shape) (forget D (FC := FD) (CC := CD))
inst_4 : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst_5 : ∀ (P : Functor.{v, w', u, w} Cᵒᵖ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst_6 : ∀ (X : C), PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D (FC := FD) (CC := CD))
X : C
P : Functor.{v, w', u, w} Cᵒᵖ D
x : ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.plusObj P).obj (op X))
S : (J.Cover X)ᵒᵖ
y : ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.diagram P X).obj S)
h :
  (ConcreteCategory.hom (FC := FD) (CC := CD) (colimit.ι (J.diagram P X) S) :
        (a : CD ((J.diagram P X).obj S)) → CD (colimit (J.diagram P X)))
      y =
    x
⊢ Eq (α := ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.plusObj P).obj (op X)))
    ((ConcreteCategory.hom (FC := FD) (CC := CD) (colimit.ι (J.diagram P X) S) :
          (a : CD (multiequalizer ((unop S).index P))) → CD (colimit (J.diagram P X)))
        y :
      CD (colimit (J.diagram P X)))
    ((ConcreteCategory.hom (FC := FD) (CC := CD) (colimit.ι (J.diagram P X) S) :
          (a : CD (multiequalizer ((unop S).index P))) → CD (colimit (J.diagram P X)))
        ((Equiv.symm (Meq.equiv (FD := FD) (CD := CD) P (unop S)) :
              (a : Meq P (unop S)) → ToType (multiequalizer ((unop S).index P)))
            ((Meq.equiv (FD := FD) (CD := CD) P (unop S) :
                (a : ToType (multiequalizer ((unop S).index P))) → Meq P (unop S))
              y) :
          ToType.{t, w', w, u_1} (FC := FD) (CC := CD) (multiequalizer ((unop S).index P))) :
      CD (colimit (J.diagram P X)))

Tactic:
simp
-- Module: Mathlib.CategoryTheory.Sites.ConcreteSheafification
Goal:
C : Type u
inst : Category.{v, u} C
J : GrothendieckTopology.{v, u} C
D : Type w
inst_1 : Category.{w', w} D
FD : D → D → Type u_1
CD : D → Type t
inst_2 : (X Y : D) → FunLike.{u_1 + 1, t + 1, t + 1} (FD X Y) (CD X) (CD Y)
instCC : ConcreteCategory.{t, w', w, u_1} D FD (CC := CD)
inst_3 : ∀ {X : C} (S : J.Cover X), PreservesLimitsOfShape (WalkingMulticospan S.shape) (forget D (FC := FD) (CC := CD))
inst_4 : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst_5 : ∀ (P : Functor.{v, w', u, w} Cᵒᵖ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst_6 : ∀ (X : C), PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D (FC := FD) (CC := CD))
X : C
P : Functor.{v, w', u, w} Cᵒᵖ D
S T : J.Cover X
x : Meq (FD := FD) (CD := CD) P S
y : Meq (FD := FD) (CD := CD) P T
mp :
  Eq (α := ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.plusObj P).obj (op X))) (mk (FD := FD) (CD := CD) x)
      (mk (FD := FD) (CD := CD) y) →
    ∃ (W : J.Cover X) (h1 : W ⟶ S) (h2 : W ⟶ T), x.refine (FD := FD) (CD := CD) h1 = y.refine (FD := FD) (CD := CD) h2
mpr :
  (∃ (W : J.Cover X) (h1 : W ⟶ S) (h2 : W ⟶ T), x.refine (FD := FD) (CD := CD) h1 = y.refine (FD := FD) (CD := CD) h2) →
    Eq (α := ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.plusObj P).obj (op X))) (mk (FD := FD) (CD := CD) x)
      (mk (FD := FD) (CD := CD) y)
⊢ Eq (α := ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.plusObj P).obj (op X))) (mk (FD := FD) (CD := CD) x)
      (mk (FD := FD) (CD := CD) y) ↔
    ∃ (W : J.Cover X) (h1 : W ⟶ S) (h2 : W ⟶ T), x.refine (FD := FD) (CD := CD) h1 = y.refine (FD := FD) (CD := CD) h2

Tactic:
constructor
-- Module: Mathlib.CategoryTheory.Sites.ConcreteSheafification
Goal:
C : Type u
inst : Category.{v, u} C
J : GrothendieckTopology.{v, u} C
D : Type w
inst_1 : Category.{w', w} D
FD : D → D → Type u_1
CD : D → Type t
inst_2 : (X Y : D) → FunLike.{u_1 + 1, t + 1, t + 1} (FD X Y) (CD X) (CD Y)
instCC : ConcreteCategory.{t, w', w, u_1} D FD (CC := CD)
inst_3 : ∀ {X : C} (S : J.Cover X), PreservesLimitsOfShape (WalkingMulticospan S.shape) (forget D (FC := FD) (CC := CD))
inst_4 : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst_5 : ∀ (P : Functor.{v, w', u, w} Cᵒᵖ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst_6 : ∀ (X : C), PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D (FC := FD) (CC := CD))
X : C
P : Functor.{v, w', u, w} Cᵒᵖ D
S T : J.Cover X
x : Meq (FD := FD) (CD := CD) P S
y : Meq (FD := FD) (CD := CD) P T
h :
  Eq (α := ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.plusObj P).obj (op X))) (mk (FD := FD) (CD := CD) x)
    (mk (FD := FD) (CD := CD) y)
mp :
  ∀ (W : (J.Cover X)ᵒᵖ) (h1 : op S ⟶ W) (h2 : op T ⟶ W)
    (hh :
      Eq.{t + 1} (α := CD ((J.diagram P X).obj W))
        ((ConcreteCategory.hom (FC := FD) (CC := CD) ((J.diagram P X).map h1) :
              (a : CD ((J.diagram P X).obj (op S))) → CD ((J.diagram P X).obj W))
            ((Equiv.symm (Meq.equiv (FD := FD) (CD := CD) P S) : (a : Meq P S) → ToType (multiequalizer (S.index P)))
                x :
              ToType.{t, w', w, u_1} (FC := FD) (CC := CD) (multiequalizer (S.index P))) :
          CD ((J.diagram P X).obj W))
        ((ConcreteCategory.hom (FC := FD) (CC := CD) ((J.diagram P X).map h2) :
              (a : CD ((J.diagram P X).obj (op T))) → CD ((J.diagram P X).obj W))
            ((Equiv.symm (Meq.equiv (FD := FD) (CD := CD) P T) : (a : Meq P T) → ToType (multiequalizer (T.index P)))
                y :
              ToType.{t, w', w, u_1} (FC := FD) (CC := CD) (multiequalizer (T.index P))) :
          CD ((J.diagram P X).obj W))),
    ∃ (W : J.Cover X) (h1 : W ⟶ S) (h2 : W ⟶ T), x.refine (FD := FD) (CD := CD) h1 = y.refine (FD := FD) (CD := CD) h2
⊢ ∃ (W : J.Cover X) (h1 : W ⟶ S) (h2 : W ⟶ T), x.refine (FD := FD) (CD := CD) h1 = y.refine (FD := FD) (CD := CD) h2

Tactic:
obtain ⟨W, h1, h2, hh⟩ := Concrete.colimit_exists_of_rep_eq (C := D) _ _ _ h

Premises used: CategoryTheory.Limits.Concrete.colimit_exists_of_rep_eq
-- Module: Mathlib.CategoryTheory.Sites.ConcreteSheafification
Goal:
C : Type u
inst : Category.{v, u} C
J : GrothendieckTopology.{v, u} C
D : Type w
inst_1 : Category.{w', w} D
FD : D → D → Type u_1
CD : D → Type t
inst_2 : (X Y : D) → FunLike.{u_1 + 1, t + 1, t + 1} (FD X Y) (CD X) (CD Y)
instCC : ConcreteCategory.{t, w', w, u_1} D FD (CC := CD)
inst_3 : ∀ {X : C} (S : J.Cover X), PreservesLimitsOfShape (WalkingMulticospan S.shape) (forget D (FC := FD) (CC := CD))
inst_4 : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst_5 : ∀ (P : Functor.{v, w', u, w} Cᵒᵖ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst_6 : ∀ (X : C), PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D (FC := FD) (CC := CD))
X : C
P : Functor.{v, w', u, w} Cᵒᵖ D
S T : J.Cover X
x : Meq (FD := FD) (CD := CD) P S
y : Meq (FD := FD) (CD := CD) P T
h :
  Eq (α := ToType.{t, w', w, u_1} (FC := FD) (CC := CD) ((J.plusObj P).obj (op X))) (mk (FD := FD) (CD := CD) x)
    (mk (FD := FD) (CD := CD) y)
W : (J.Cover X)ᵒᵖ
h1 : op S ⟶ W
h2 : op T ⟶ W
hh :
  Eq.{t + 1} (α := CD ((J.diagram P X).obj W))
    ((ConcreteCategory.hom (FC := FD) (CC := CD) ((J.diagram P X).map h1) :
          (a : CD ((J.diagram P X).obj (op S))) → CD ((J.diagram P X).obj W))
        ((Equiv.symm (Meq.equiv (FD := FD) (CD := CD) P S) : (a : Meq P S) → ToType (multiequalizer (S.index P))) x :
          ToType.{t, w', w, u_1} (FC := FD) (CC := CD) (multiequalizer (S.index P))) :
      CD ((J.diagram P X).obj W))
    ((ConcreteCategory.hom (FC := FD) (CC := CD) ((J.diagram P X).map h2) :
          (a : CD ((J.diagram P X).obj (op T))) → CD ((J.diagram P X).obj W))
        ((Equiv.symm (Meq.equiv (FD := FD) (CD := CD) P T) : (a : Meq P T) → ToType (multiequalizer (T.index P))) y :
          ToType.{t, w', w, u_1} (FC := FD) (CC := CD) (multiequalizer (T.index P))) :
      CD ((J.diagram P X).obj W))
h₁ : x.refine (FD := FD) (CD := CD) h1.unop = y.refine (FD := FD) (CD := CD) h2.unop
⊢ ∃ (W : J.Cover X) (h1 : W ⟶ S) (h2 : W ⟶ T), x.refine (FD := FD) (CD := CD) h1 = y.refine (FD := FD) (CD := CD) h2

Tactic:
use W.unop, h1.unop, h2.unop

Premises used: Quiver.Hom.unop, Opposite.unop