ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Sheaf.adjunctionToTypes_counit_app_val
@[simp]
theorem adjunctionToTypes_counit_app_val {G : Type max v₁ u₁ ⥤ D} (adj : G ⊣ forget D)
    (X : Sheaf J D) :
    ((adjunctionToTypes J adj).counit.app X).val =
      sheafifyLift J ((Functor.associator _ _ _).hom ≫ (adj.whiskerRight _).counit.app _) X.2 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.HasWeakSheafify J D] [CategoryTheory.ConcreteCategory D] [J.HasSheafCompose (CategoryTheory.forget D)] {G : CategoryTheory.Functor (Type (max v₁ u₁)) D} (adj : G ⊣ CategoryTheory.forget D) (X : CategoryTheory.Sheaf J D)
Goal: ((CategoryTheory.Sheaf.adjunctionToTypes J adj).counit.app X).val =
  CategoryTheory.sheafifyLift J
    (CategoryTheory.CategoryStruct.comp (X.1.associator (CategoryTheory.forget D) G).hom
      ((CategoryTheory.Adjunction.whiskerRight Cᵒᵖ adj).counit.app X.1))
    ⋯
-- CategoryTheory.presheafHom_obj
@[simps! obj]
def presheafHom : Cᵒᵖ ⥤ Type _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u'} [CategoryTheory.Category.{v', u'} A] (F G : CategoryTheory.Functor Cᵒᵖ A) (X : Cᵒᵖ)
Goal: (CategoryTheory.presheafHom F G).obj X =
  ((CategoryTheory.Over.forget (Opposite.unop X)).op.comp F ⟶ (CategoryTheory.Over.forget (Opposite.unop X)).op.comp G)
-- CategoryTheory.presheafHom_map_app
lemma presheafHom_map_app {X Y Z : C} (f : Z ⟶ Y) (g : Y ⟶ X) (h : Z ⟶ X) (w : f ≫ g = h)
    (α : (presheafHom F G).obj (op X)) :
    ((presheafHom F G).map g.op α).app (op (Over.mk f)) =
      α.app (op (Over.mk h)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u'} [CategoryTheory.Category.{v', u'} A] {F G : CategoryTheory.Functor Cᵒᵖ A} {X Y Z : C} (f : Z ⟶ Y) (g : Y ⟶ X) (h : Z ⟶ X) (w : CategoryTheory.CategoryStruct.comp f g = h) (α : (CategoryTheory.presheafHom F G).obj (Opposite.op X))
Goal: ((CategoryTheory.presheafHom F G).map g.op α).app (Opposite.op (CategoryTheory.Over.mk f)) =
  α.app (Opposite.op (CategoryTheory.Over.mk h))
-- CategoryTheory.presheafHom_map_app_op_mk_id
@[simp]
lemma presheafHom_map_app_op_mk_id {X Y : C} (g : Y ⟶ X)
    (α : (presheafHom F G).obj (op X)) :
    ((presheafHom F G).map g.op α).app (op (Over.mk (𝟙 Y))) =
      α.app (op (Over.mk g)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u'} [CategoryTheory.Category.{v', u'} A] {F G : CategoryTheory.Functor Cᵒᵖ A} {X Y : C} (g : Y ⟶ X) (α : (CategoryTheory.presheafHom F G).obj (Opposite.op X))
Goal: ((CategoryTheory.presheafHom F G).map g.op α).app
    (Opposite.op (CategoryTheory.Over.mk (CategoryTheory.CategoryStruct.id Y))) =
  α.app (Opposite.op (CategoryTheory.Over.mk g))
-- CategoryTheory.PresheafHom.isAmalgamation_iff
lemma PresheafHom.isAmalgamation_iff {X : C} (S : Sieve X)
    (x : Presieve.FamilyOfElements (presheafHom F G) S.arrows)
    (hx : x.Compatible) (y : (presheafHom F G).obj (op X)) :
    x.IsAmalgamation y ↔ ∀ (Y : C) (g : Y ⟶ X) (hg : S g),
      y.app (op (Over.mk g)) = (x g hg).app (op (Over.mk (𝟙 Y))) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u'} [CategoryTheory.Category.{v', u'} A] {F G : CategoryTheory.Functor Cᵒᵖ A} {X : C} (S : CategoryTheory.Sieve X) (x : CategoryTheory.Presieve.FamilyOfElements (CategoryTheory.presheafHom F G) S.arrows) (hx : x.Compatible) (y : (CategoryTheory.presheafHom F G).obj (Opposite.op X))
Goal: x.IsAmalgamation y ↔
  ∀ (Y : C) (g : Y ⟶ X) (hg : S.arrows g),
    y.app (Opposite.op (CategoryTheory.Over.mk g)) =
      (x g hg).app (Opposite.op (CategoryTheory.Over.mk (CategoryTheory.CategoryStruct.id Y)))
-- CategoryTheory.PresheafHom.IsSheafFor.exists_app
lemma exists_app :
    ∃ (φ : F.obj (op Y) ⟶ G.obj (op Y)),
      ∀ {Z : C} (p : Z ⟶ Y) (hp : S (p ≫ g)), φ ≫ G.map p.op =
        F.map p.op ≫ (x (p ≫ g) hp).app ⟨Over.mk (𝟙 Z)⟩ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u'} [CategoryTheory.Category.{v', u'} A] {F G : CategoryTheory.Functor Cᵒᵖ A} {X : C} {S : CategoryTheory.Sieve X} (hG :
  ⦃Y : C⦄ →
    (f : Y ⟶ X) → CategoryTheory.Limits.IsLimit (G.mapCone (CategoryTheory.Sieve.pullback f S).arrows.cocone.op)) (x : CategoryTheory.Presieve.FamilyOfElements (CategoryTheory.presheafHom F G) S.arrows) (hx : x.Compatible) {Y : C} (g : Y ⟶ X)
Goal: ∃ φ,
  ∀ {Z : C} (p : Z ⟶ Y) (hp : S.arrows (CategoryTheory.CategoryStruct.comp p g)),
    CategoryTheory.CategoryStruct.comp φ (G.map p.op) =
      CategoryTheory.CategoryStruct.comp (F.map p.op)
        ((x (CategoryTheory.CategoryStruct.comp p g) hp).app
          (Opposite.op (CategoryTheory.Over.mk (CategoryTheory.CategoryStruct.id Z))))
-- CategoryTheory.PresheafHom.IsSheafFor.app_cond
lemma app_cond {Z : C} (p : Z ⟶ Y) (hp : S (p ≫ g)) :
    app hG x hx g ≫ G.map p.op = F.map p.op ≫ (x (p ≫ g) hp).app ⟨Over.mk (𝟙 Z)⟩ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u'} [CategoryTheory.Category.{v', u'} A] {F G : CategoryTheory.Functor Cᵒᵖ A} {X : C} {S : CategoryTheory.Sieve X} (hG :
  ⦃Y : C⦄ →
    (f : Y ⟶ X) → CategoryTheory.Limits.IsLimit (G.mapCone (CategoryTheory.Sieve.pullback f S).arrows.cocone.op)) (x : CategoryTheory.Presieve.FamilyOfElements (CategoryTheory.presheafHom F G) S.arrows) (hx : x.Compatible) {Y : C} (g : Y ⟶ X) {Z : C} (p : Z ⟶ Y) (hp : S.arrows (CategoryTheory.CategoryStruct.comp p g))
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.PresheafHom.IsSheafFor.app hG x hx g) (G.map p.op) =
  CategoryTheory.CategoryStruct.comp (F.map p.op)
    ((x (CategoryTheory.CategoryStruct.comp p g) hp).app
      (Opposite.op (CategoryTheory.Over.mk (CategoryTheory.CategoryStruct.id Z))))
-- CategoryTheory.presheafHom_isSheafFor
lemma presheafHom_isSheafFor  :
    Presieve.IsSheafFor (presheafHom F G) S.arrows 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u'} [CategoryTheory.Category.{v', u'} A] (F G : CategoryTheory.Functor Cᵒᵖ A) {X : C} (S : CategoryTheory.Sieve X) (hG :
  ⦃Y : C⦄ →
    (f : Y ⟶ X) → CategoryTheory.Limits.IsLimit (G.mapCone (CategoryTheory.Sieve.pullback f S).arrows.cocone.op))
Goal: CategoryTheory.Presieve.IsSheafFor (CategoryTheory.presheafHom F G) S.arrows
-- CategoryTheory.Presheaf.IsSheaf.hom
lemma Presheaf.IsSheaf.hom (hG : Presheaf.IsSheaf J G) :
    Presheaf.IsSheaf J (presheafHom F G) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] (F G : CategoryTheory.Functor Cᵒᵖ A) (hG : CategoryTheory.Presheaf.IsSheaf J G)
Goal: CategoryTheory.Presheaf.IsSheaf J (CategoryTheory.presheafHom F G)
-- CategoryTheory.sheafHomSectionsEquiv_symm_apply_coe_apply
@[simp]
lemma sheafHomSectionsEquiv_symm_apply_coe_apply {F G : Sheaf J A} (φ : F ⟶ G) (X : Cᵒᵖ) :
    ((sheafHomSectionsEquiv F G).symm φ).1 X = (J.overPullback A X.unop).map φ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] {F G : CategoryTheory.Sheaf J A} (φ : F ⟶ G) (X : Cᵒᵖ)
Goal: ↑((CategoryTheory.sheafHomSectionsEquiv F G).symm φ) X = (J.overPullback A (Opposite.unop X)).map φ
-- CategoryTheory.Groupoid.Free.congr_reverse
theorem congr_reverse {X Y : Paths <| Quiver.Symmetrify V} (p q : X ⟶ Y) :
    Quotient.CompClosure redStep p q → Quotient.CompClosure redStep p.reverse q.reverse 
Arguments: {V : Type u} [Quiver V] {X Y : CategoryTheory.Paths (Quiver.Symmetrify V)} (p q : X ⟶ Y)
Goal: CategoryTheory.Quotient.CompClosure CategoryTheory.Groupoid.Free.redStep p q →
  CategoryTheory.Quotient.CompClosure CategoryTheory.Groupoid.Free.redStep (Quiver.Path.reverse p)
    (Quiver.Path.reverse q)
-- CategoryTheory.Groupoid.Free.congr_comp_reverse
theorem congr_comp_reverse {X Y : Paths <| Quiver.Symmetrify V} (p : X ⟶ Y) :
    Quot.mk (@Quotient.CompClosure _ _ redStep _ _) (p ≫ p.reverse) =
      Quot.mk (@Quotient.CompClosure _ _ redStep _ _) (𝟙 X) 
Arguments: {V : Type u} [Quiver V] {X Y : CategoryTheory.Paths (Quiver.Symmetrify V)} (p : X ⟶ Y)
Goal: Quot.mk (CategoryTheory.Quotient.CompClosure CategoryTheory.Groupoid.Free.redStep)
    (CategoryTheory.CategoryStruct.comp p (Quiver.Path.reverse p)) =
  Quot.mk (CategoryTheory.Quotient.CompClosure CategoryTheory.Groupoid.Free.redStep)
    (CategoryTheory.CategoryStruct.id X)
-- CategoryTheory.Groupoid.Free.congr_reverse_comp
theorem congr_reverse_comp {X Y : Paths <| Quiver.Symmetrify V} (p : X ⟶ Y) :
    Quot.mk (@Quotient.CompClosure _ _ redStep _ _) (p.reverse ≫ p) =
      Quot.mk (@Quotient.CompClosure _ _ redStep _ _) (𝟙 Y) 
Arguments: {V : Type u} [Quiver V] {X Y : CategoryTheory.Paths (Quiver.Symmetrify V)} (p : X ⟶ Y)
Goal: Quot.mk (CategoryTheory.Quotient.CompClosure CategoryTheory.Groupoid.Free.redStep)
    (CategoryTheory.CategoryStruct.comp (Quiver.Path.reverse p) p) =
  Quot.mk (CategoryTheory.Quotient.CompClosure CategoryTheory.Groupoid.Free.redStep)
    (CategoryTheory.CategoryStruct.id Y)
-- CategoryTheory.Groupoid.Free.of_eq
theorem of_eq :
    of V = (Quiver.Symmetrify.of ⋙q Paths.of).comp
      (Quotient.functor <| @redStep V _).toPrefunctor 
Arguments: {V : Type u} [Quiver V]
Goal: CategoryTheory.Groupoid.Free.of V =
  Quiver.Symmetrify.of ⋙q CategoryTheory.Paths.of ⋙q
    (CategoryTheory.Quotient.functor CategoryTheory.Groupoid.Free.redStep).toPrefunctor
-- CategoryTheory.Groupoid.Free.lift_spec
theorem lift_spec (φ : V ⥤q V') : of V ⋙q (lift φ).toPrefunctor = φ 
Arguments: {V : Type u} [Quiver V] {V' : Type u'} [CategoryTheory.Groupoid V'] (φ : V ⥤q V')
Goal: CategoryTheory.Groupoid.Free.of V ⋙q (CategoryTheory.Groupoid.Free.lift φ).toPrefunctor = φ
-- CategoryTheory.Groupoid.Free.lift_unique
theorem lift_unique (φ : V ⥤q V') (Φ : FreeGroupoid V ⥤ V') (hΦ : of V ⋙q Φ.toPrefunctor = φ) :
    Φ = lift φ 
Arguments: {V : Type u} [Quiver V] {V' : Type u'} [CategoryTheory.Groupoid V'] (φ : V ⥤q V') (Φ : CategoryTheory.Functor (CategoryTheory.FreeGroupoid V) V') (hΦ : CategoryTheory.Groupoid.Free.of V ⋙q Φ.toPrefunctor = φ)
Goal: Φ = CategoryTheory.Groupoid.Free.lift φ
-- CategoryTheory.Groupoid.Free.freeGroupoidFunctor_id
theorem freeGroupoidFunctor_id :
    freeGroupoidFunctor (Prefunctor.id V) = Functor.id (FreeGroupoid V) 
Arguments: {V : Type u} [Quiver V]
Goal: CategoryTheory.freeGroupoidFunctor (𝟭q V) = CategoryTheory.Functor.id (CategoryTheory.FreeGroupoid V)
-- CategoryTheory.Groupoid.Free.freeGroupoidFunctor_comp
theorem freeGroupoidFunctor_comp (φ : V ⥤q V') (φ' : V' ⥤q V'') :
    freeGroupoidFunctor (φ ⋙q φ') = freeGroupoidFunctor φ ⋙ freeGroupoidFunctor φ' 
Arguments: {V : Type u} [Quiver V] {V' : Type u'} [Quiver V'] {V'' : Type u''} [Quiver V''] (φ : V ⥤q V') (φ' : V' ⥤q V'')
Goal: CategoryTheory.freeGroupoidFunctor (φ ⋙q φ') =
  (CategoryTheory.freeGroupoidFunctor φ).comp (CategoryTheory.freeGroupoidFunctor φ')
-- CategoryTheory.Core.id_hom
@[simp]
/- Porting note: abomination -/
theorem id_hom (X : C) : Iso.hom (coreCategory.id X) = @CategoryStruct.id C _ X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C)
Goal: (CategoryTheory.CategoryStruct.id X).hom = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Core.comp_hom
@[simp]
theorem comp_hom {X Y Z : Core C} (f : X ⟶ Y) (g : Y ⟶ Z) : (f ≫ g).hom = f.hom ≫ g.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : CategoryTheory.Core C} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: (CategoryTheory.CategoryStruct.comp f g).hom = CategoryTheory.CategoryStruct.comp f.hom g.hom
-- CategoryTheory.IsSkeletonOf.skel
structure IsSkeletonOf (F : D ⥤ C) : Prop where
    skel : Skeletal D
    eqv : F.IsEquivalence := by infer_instance
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor D C} (self : CategoryTheory.IsSkeletonOf C D F)
Goal: CategoryTheory.Skeletal D
-- CategoryTheory.IsSkeletonOf.eqv
structure IsSkeletonOf (F : D ⥤ C) : Prop where
    skel : Skeletal D
    eqv : F.IsEquivalence := by infer_instance
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor D C} (self : CategoryTheory.IsSkeletonOf C D F)
Goal: F.IsEquivalence
-- CategoryTheory.Functor.eq_of_iso
theorem Functor.eq_of_iso {F₁ F₂ : D ⥤ C} [Quiver.IsThin C] (hC : Skeletal C) (hF : F₁ ≅ F₂) :
    F₁ = F₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F₁ F₂ : CategoryTheory.Functor D C} [Quiver.IsThin C] (hC : CategoryTheory.Skeletal C) (hF : F₁ ≅ F₂)
Goal: F₁ = F₂
-- CategoryTheory.functor_skeletal
theorem functor_skeletal [Quiver.IsThin C] (hC : Skeletal C) : Skeletal (D ⥤ C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [Quiver.IsThin C] (hC : CategoryTheory.Skeletal C)
Goal: CategoryTheory.Skeletal (CategoryTheory.Functor D C)
-- CategoryTheory.fromSkeleton_map
@[simps!]
noncomputable def fromSkeleton : Skeleton C ⥤ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : CategoryTheory.InducedCategory C Quotient.out} (f : X ⟶ Y), (CategoryTheory.fromSkeleton C).map f = f
-- CategoryTheory.fromSkeleton_obj
@[simps!]
noncomputable def fromSkeleton : Skeleton C ⥤ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ (a : Quotient (CategoryTheory.isIsomorphicSetoid C)), (CategoryTheory.fromSkeleton C).obj a = a.out
-- CategoryTheory.skeleton_skeletal
theorem skeleton_skeletal : Skeletal (Skeleton C) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: CategoryTheory.Skeletal (CategoryTheory.Skeleton C)
-- CategoryTheory.skeleton_isSkeleton
lemma skeleton_isSkeleton : IsSkeletonOf C (Skeleton C) (fromSkeleton C) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: CategoryTheory.IsSkeletonOf C (CategoryTheory.Skeleton C) (CategoryTheory.fromSkeleton C)
-- CategoryTheory.toThinSkeleton_map
@[simps]
def toThinSkeleton : C ⥤ ThinSkeleton C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.toThinSkeleton C).map f = CategoryTheory.homOfLE ⋯
-- CategoryTheory.toThinSkeleton_obj
@[simps]
def toThinSkeleton : C ⥤ ThinSkeleton C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (a : C)
Goal: (CategoryTheory.toThinSkeleton C).obj a = Quotient.mk' a
-- CategoryTheory.ThinSkeleton.map_map
@[simps]
def map (F : C ⥤ D) : ThinSkeleton C ⥤ ThinSkeleton D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : CategoryTheory.ThinSkeleton C}
Goal: ∀ (a : X ⟶ Y),
  (CategoryTheory.ThinSkeleton.map F).map a =
    Quotient.recOnSubsingleton₂ (motive := fun x x_1 => (x ⟶ x_1) → (Quotient.map F.obj ⋯ x ⟶ Quotient.map F.obj ⋯ x_1))
      X Y (fun x y k => CategoryTheory.homOfLE ⋯) a
-- CategoryTheory.ThinSkeleton.map_obj
@[simps]
def map (F : C ⥤ D) : ThinSkeleton C ⥤ ThinSkeleton D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D)
Goal: ∀ (a : Quotient (CategoryTheory.isIsomorphicSetoid C)),
  (CategoryTheory.ThinSkeleton.map F).obj a = Quotient.map F.obj ⋯ a
-- CategoryTheory.ThinSkeleton.comp_toThinSkeleton
theorem comp_toThinSkeleton (F : C ⥤ D) : F ⋙ toThinSkeleton D = toThinSkeleton C ⋙ map F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D)
Goal: F.comp (CategoryTheory.toThinSkeleton D) = (CategoryTheory.toThinSkeleton C).comp (CategoryTheory.ThinSkeleton.map F)
-- CategoryTheory.ThinSkeleton.map₂_obj
@[simps]
def map₂ (F : C ⥤ D ⥤ E) : ThinSkeleton C ⥤ ThinSkeleton D ⥤ ThinSkeleton E 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C (CategoryTheory.Functor D E))
Goal: ∀ (a : CategoryTheory.ThinSkeleton C),
  (CategoryTheory.ThinSkeleton.map₂ F).obj a = CategoryTheory.ThinSkeleton.map₂Functor F a
-- CategoryTheory.ThinSkeleton.map₂_map
@[simps]
def map₂ (F : C ⥤ D ⥤ E) : ThinSkeleton C ⥤ ThinSkeleton D ⥤ ThinSkeleton E 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C (CategoryTheory.Functor D E))
Goal: ∀ {X Y : CategoryTheory.ThinSkeleton C} (a : X ⟶ Y),
  (CategoryTheory.ThinSkeleton.map₂ F).map a = CategoryTheory.ThinSkeleton.map₂NatTrans F a
-- CategoryTheory.ThinSkeleton.fromThinSkeleton_map
@[simps]
noncomputable def fromThinSkeleton : ThinSkeleton C ⥤ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [Quiver.IsThin C] {x y : CategoryTheory.ThinSkeleton C}
Goal: ∀ (a : x ⟶ y),
  (CategoryTheory.ThinSkeleton.fromThinSkeleton C).map a =
    Quotient.recOnSubsingleton₂ (motive := fun x x_1 => (x ⟶ x_1) → (Quotient.out x ⟶ Quotient.out x_1)) x y
      (fun X Y f =>
        CategoryTheory.CategoryStruct.comp (Nonempty.some ⋯).hom
          (CategoryTheory.CategoryStruct.comp (Nonempty.some ⋯) (Nonempty.some ⋯).inv))
      a
-- CategoryTheory.ThinSkeleton.fromThinSkeleton_obj
@[simps]
noncomputable def fromThinSkeleton : ThinSkeleton C ⥤ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [Quiver.IsThin C]
Goal: ∀ (a : Quotient (CategoryTheory.isIsomorphicSetoid C)), (CategoryTheory.ThinSkeleton.fromThinSkeleton C).obj a = a.out
-- CategoryTheory.ThinSkeleton.equiv_of_both_ways
theorem equiv_of_both_ways {X Y : C} (f : X ⟶ Y) (g : Y ⟶ X) : X ≈ Y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [Quiver.IsThin C] {X Y : C} (f : X ⟶ Y) (g : Y ⟶ X)
Goal: X ≈ Y
-- CategoryTheory.ThinSkeleton.skeletal
theorem skeletal : Skeletal (ThinSkeleton C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [Quiver.IsThin C]
Goal: CategoryTheory.Skeletal (CategoryTheory.ThinSkeleton C)
-- CategoryTheory.ThinSkeleton.map_comp_eq
theorem map_comp_eq (F : E ⥤ D) (G : D ⥤ C) : map (F ⋙ G) = map F ⋙ map G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] [Quiver.IsThin C] (F : CategoryTheory.Functor E D) (G : CategoryTheory.Functor D C)
Goal: CategoryTheory.ThinSkeleton.map (F.comp G) =
  (CategoryTheory.ThinSkeleton.map F).comp (CategoryTheory.ThinSkeleton.map G)
-- CategoryTheory.ThinSkeleton.map_id_eq
theorem map_id_eq : map (𝟭 C) = 𝟭 (ThinSkeleton C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [Quiver.IsThin C]
Goal: CategoryTheory.ThinSkeleton.map (CategoryTheory.Functor.id C) =
  CategoryTheory.Functor.id (CategoryTheory.ThinSkeleton C)
-- CategoryTheory.ThinSkeleton.map_iso_eq
theorem map_iso_eq {F₁ F₂ : D ⥤ C} (h : F₁ ≅ F₂) : map F₁ = map F₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [Quiver.IsThin C] {F₁ F₂ : CategoryTheory.Functor D C} (h : F₁ ≅ F₂)
Goal: CategoryTheory.ThinSkeleton.map F₁ = CategoryTheory.ThinSkeleton.map F₂
-- CategoryTheory.ThinSkeleton.thinSkeleton_isSkeleton
lemma thinSkeleton_isSkeleton : IsSkeletonOf C (ThinSkeleton C) (fromThinSkeleton C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [Quiver.IsThin C]
Goal: CategoryTheory.IsSkeletonOf C (CategoryTheory.ThinSkeleton C) (CategoryTheory.ThinSkeleton.fromThinSkeleton C)
-- CategoryTheory.GrothendieckTopology.PreservesSheafification.le
class PreservesSheafification : Prop where
  le : J.W ≤ J.W.inverseImage ((whiskeringRight Cᵒᵖ A B).obj F)
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u_1} {B : Type u_2} [CategoryTheory.Category.{u_3, u_1} A] [CategoryTheory.Category.{u_4, u_2} B] {F : CategoryTheory.Functor A B} [self : J.PreservesSheafification F]
Goal: J.W ≤ J.W.inverseImage ((CategoryTheory.whiskeringRight Cᵒᵖ A B).obj F)
-- CategoryTheory.GrothendieckTopology.W_of_preservesSheafification
lemma W_of_preservesSheafification
    {P₁ P₂ : Cᵒᵖ ⥤ A} (f : P₁ ⟶ P₂) (hf : J.W f) :
    J.W (whiskerRight f F) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u_1} {B : Type u_2} [CategoryTheory.Category.{u_3, u_1} A] [CategoryTheory.Category.{u_4, u_2} B] (F : CategoryTheory.Functor A B) [J.PreservesSheafification F] {P₁ P₂ : CategoryTheory.Functor Cᵒᵖ A} (f : P₁ ⟶ P₂) (hf : J.W f)
Goal: J.W (CategoryTheory.whiskerRight f F)
-- CategoryTheory.GrothendieckTopology.W_isInvertedBy_whiskeringRight_presheafToSheaf
lemma W_isInvertedBy_whiskeringRight_presheafToSheaf :
    J.W.IsInvertedBy (((whiskeringRight Cᵒᵖ A B).obj F) ⋙ presheafToSheaf J B) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u_1} {B : Type u_2} [CategoryTheory.Category.{u_3, u_1} A] [CategoryTheory.Category.{u_4, u_2} B] (F : CategoryTheory.Functor A B) [J.PreservesSheafification F] [CategoryTheory.HasWeakSheafify J B]
Goal: J.W.IsInvertedBy (((CategoryTheory.whiskeringRight Cᵒᵖ A B).obj F).comp (CategoryTheory.presheafToSheaf J B))
-- CategoryTheory.toPresheafToSheafCompComposeAndSheafify_app
@[simps!]
noncomputable def toPresheafToSheafCompComposeAndSheafify :
    (whiskeringRight Cᵒᵖ A B).obj F ⋙ presheafToSheaf J B ⟶
      presheafToSheaf J A ⋙ Sheaf.composeAndSheafify J F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u_1} {B : Type u_2} [CategoryTheory.Category.{u_3, u_1} A] [CategoryTheory.Category.{u_4, u_2} B] (F : CategoryTheory.Functor A B) [CategoryTheory.HasWeakSheafify J B] [CategoryTheory.HasWeakSheafify J A] (X : CategoryTheory.Functor Cᵒᵖ A)
Goal: (CategoryTheory.toPresheafToSheafCompComposeAndSheafify J F).app X =
  (CategoryTheory.presheafToSheaf J B).map (CategoryTheory.whiskerRight (CategoryTheory.toSheafify J X) F)
-- CategoryTheory.presheafToSheafCompComposeAndSheafifyIso_inv_app
@[simps! inv_app]
noncomputable def presheafToSheafCompComposeAndSheafifyIso :
    presheafToSheaf J A ⋙ Sheaf.composeAndSheafify J F ≅
      (whiskeringRight Cᵒᵖ A B).obj F ⋙ presheafToSheaf J B 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u_1} {B : Type u_2} [CategoryTheory.Category.{u_3, u_1} A] [CategoryTheory.Category.{u_4, u_2} B] (F : CategoryTheory.Functor A B) [CategoryTheory.HasWeakSheafify J B] [CategoryTheory.HasWeakSheafify J A] [J.PreservesSheafification F] (X : CategoryTheory.Functor Cᵒᵖ A)
Goal: (CategoryTheory.presheafToSheafCompComposeAndSheafifyIso J F).inv.app X =
  (CategoryTheory.presheafToSheaf J B).map (CategoryTheory.whiskerRight (CategoryTheory.toSheafify J X) F)
-- CategoryTheory.GrothendieckTopology.preservesSheafification_iff_of_adjunctions
lemma GrothendieckTopology.preservesSheafification_iff_of_adjunctions :
    J.PreservesSheafification F ↔ ∀ (P : Cᵒᵖ ⥤ A),
      IsIso (G₂.map (whiskerRight (adj₁.unit.app P) F)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u_1} {B : Type u_2} [CategoryTheory.Category.{u_3, u_1} A] [CategoryTheory.Category.{u_4, u_2} B] (F : CategoryTheory.Functor A B) {G₁ : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ A) (CategoryTheory.Sheaf J A)} (adj₁ : G₁ ⊣ CategoryTheory.sheafToPresheaf J A) {G₂ : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ B) (CategoryTheory.Sheaf J B)} (adj₂ : G₂ ⊣ CategoryTheory.sheafToPresheaf J B)
Goal: J.PreservesSheafification F ↔
  ∀ (P : CategoryTheory.Functor Cᵒᵖ A), CategoryTheory.IsIso (G₂.map (CategoryTheory.whiskerRight (adj₁.unit.app P) F))