ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.sheafEquivSheafOfTypes_functor_obj_val
@[simps]
def sheafEquivSheafOfTypes : Sheaf J (Type w) ≌ SheafOfTypes J 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (S : CategoryTheory.Sheaf J (Type w))
Goal: ((CategoryTheory.sheafEquivSheafOfTypes J).functor.obj S).val = S.val
-- CategoryTheory.sheafEquivSheafOfTypes_inverse_map_val
@[simps]
def sheafEquivSheafOfTypes : Sheaf J (Type w) ≌ SheafOfTypes J 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C)
Goal: ∀ {X Y : CategoryTheory.SheafOfTypes J} (f : X ⟶ Y),
  ((CategoryTheory.sheafEquivSheafOfTypes J).inverse.map f).val = f.val
-- CategoryTheory.sheafEquivSheafOfTypes_functor_map_val
@[simps]
def sheafEquivSheafOfTypes : Sheaf J (Type w) ≌ SheafOfTypes J 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C)
Goal: ∀ {X Y : CategoryTheory.Sheaf J (Type w)} (f : X ⟶ Y),
  ((CategoryTheory.sheafEquivSheafOfTypes J).functor.map f).val = f.val
-- CategoryTheory.sheafEquivSheafOfTypes_inverse_obj_val
@[simps]
def sheafEquivSheafOfTypes : Sheaf J (Type w) ≌ SheafOfTypes J 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (S : CategoryTheory.SheafOfTypes J)
Goal: ((CategoryTheory.sheafEquivSheafOfTypes J).inverse.obj S).val = S.val
-- CategoryTheory.Sheaf.Hom.add_app
@[simp]
theorem Sheaf.Hom.add_app (f g : P ⟶ Q) (U) : (f + g).1.app U = f.1.app U + g.1.app U 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] [CategoryTheory.Preadditive A] {P Q : CategoryTheory.Sheaf J A} (f g : P ⟶ Q) (U : Cᵒᵖ)
Goal: (f + g).val.app U = f.val.app U + g.val.app U
-- CategoryTheory.Presheaf.isSheaf_iff_multifork
theorem isSheaf_iff_multifork :
    IsSheaf J P ↔ ∀ (X : C) (S : J.Cover X), Nonempty (IsLimit (S.multifork P)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ A)
Goal: CategoryTheory.Presheaf.IsSheaf J P ↔
  ∀ (X : C) (S : J.Cover X), Nonempty (CategoryTheory.Limits.IsLimit (S.multifork P))
-- CategoryTheory.Presheaf.isSheaf_iff_multiequalizer
theorem isSheaf_iff_multiequalizer [∀ (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)] :
    IsSheaf J P ↔ ∀ (X : C) (S : J.Cover X), IsIso (S.toMultiequalizer P) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ A) [∀ (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
Goal: CategoryTheory.Presheaf.IsSheaf J P ↔ ∀ (X : C) (S : J.Cover X), CategoryTheory.IsIso (S.toMultiequalizer P)
-- CategoryTheory.Presheaf.w
theorem w : forkMap R P ≫ firstMap R P = forkMap R P ≫ secondMap R P 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {U : C} (R : CategoryTheory.Presieve U) (P : CategoryTheory.Functor Cᵒᵖ A) [CategoryTheory.Limits.HasProducts A] [CategoryTheory.Limits.HasPullbacks C]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Presheaf.forkMap R P) (CategoryTheory.Presheaf.firstMap R P) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Presheaf.forkMap R P) (CategoryTheory.Presheaf.secondMap R P)
-- CategoryTheory.Presheaf.isSheaf_iff_isSheaf'
theorem isSheaf_iff_isSheaf' : IsSheaf J P' ↔ IsSheaf' J P' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A' : Type u₂} [CategoryTheory.Category.{max v₁ u₁, u₂} A'] (J : CategoryTheory.GrothendieckTopology C) (P' : CategoryTheory.Functor Cᵒᵖ A') [CategoryTheory.Limits.HasProducts A'] [CategoryTheory.Limits.HasPullbacks C]
Goal: CategoryTheory.Presheaf.IsSheaf J P' ↔ CategoryTheory.Presheaf.IsSheaf' J P'
-- CategoryTheory.Presheaf.isSheaf_of_isSheaf_comp
theorem isSheaf_of_isSheaf_comp (s : A ⥤ B) [ReflectsLimitsOfSize.{v₁, max v₁ u₁} s]
    (h : IsSheaf J (P ⋙ s)) : IsSheaf J P 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {B : Type u₃} [CategoryTheory.Category.{v₃, u₃} B] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ A) (s : CategoryTheory.Functor A B) [CategoryTheory.Limits.ReflectsLimitsOfSize.{v₁, max v₁ u₁, v₂, v₃, u₂, u₃} s] (h : CategoryTheory.Presheaf.IsSheaf J (P.comp s))
Goal: CategoryTheory.Presheaf.IsSheaf J P
-- CategoryTheory.Presheaf.isSheaf_comp_of_isSheaf
theorem isSheaf_comp_of_isSheaf (s : A ⥤ B) [PreservesLimitsOfSize.{v₁, max v₁ u₁} s]
    (h : IsSheaf J P) : IsSheaf J (P ⋙ s) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {B : Type u₃} [CategoryTheory.Category.{v₃, u₃} B] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ A) (s : CategoryTheory.Functor A B) [CategoryTheory.Limits.PreservesLimitsOfSize.{v₁, max v₁ u₁, v₂, v₃, u₂, u₃} s] (h : CategoryTheory.Presheaf.IsSheaf J P)
Goal: CategoryTheory.Presheaf.IsSheaf J (P.comp s)
-- CategoryTheory.Presheaf.isSheaf_iff_isSheaf_comp
theorem isSheaf_iff_isSheaf_comp (s : A ⥤ B) [HasLimitsOfSize.{v₁, max v₁ u₁} A]
    [PreservesLimitsOfSize.{v₁, max v₁ u₁} s] [s.ReflectsIsomorphisms] :
    IsSheaf J P ↔ IsSheaf J (P ⋙ s) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {B : Type u₃} [CategoryTheory.Category.{v₃, u₃} B] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ A) (s : CategoryTheory.Functor A B) [CategoryTheory.Limits.HasLimitsOfSize.{v₁, max v₁ u₁, v₂, u₂} A] [CategoryTheory.Limits.PreservesLimitsOfSize.{v₁, max v₁ u₁, v₂, v₃, u₂, u₃} s] [s.ReflectsIsomorphisms]
Goal: CategoryTheory.Presheaf.IsSheaf J P ↔ CategoryTheory.Presheaf.IsSheaf J (P.comp s)
-- CategoryTheory.Presheaf.isSheaf_iff_isSheaf_forget
theorem isSheaf_iff_isSheaf_forget (s : A' ⥤ Type max v₁ u₁) [HasLimits A'] [PreservesLimits s]
    [s.ReflectsIsomorphisms] : IsSheaf J P' ↔ IsSheaf J (P' ⋙ s) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A' : Type u₂} [CategoryTheory.Category.{max v₁ u₁, u₂} A'] (J : CategoryTheory.GrothendieckTopology C) (P' : CategoryTheory.Functor Cᵒᵖ A') (s : CategoryTheory.Functor A' (Type (max v₁ u₁))) [CategoryTheory.Limits.HasLimits A'] [CategoryTheory.Limits.PreservesLimits s] [s.ReflectsIsomorphisms]
Goal: CategoryTheory.Presheaf.IsSheaf J P' ↔ CategoryTheory.Presheaf.IsSheaf J (P'.comp s)
-- CategoryTheory.Congruence.equivalence
class Congruence : Prop where
    equivalence : ∀ {X Y}, _root_.Equivalence (@r X Y)
    compLeft : ∀ {X Y Z} (f : X ⟶ Y) {g g' : Y ⟶ Z}, r g g' → r (f ≫ g) (f ≫ g')
    compRight : ∀ {X Y Z} {f f' : X ⟶ Y} (g : Y ⟶ Z), r f f' → r (f ≫ g) (f' ≫ g)
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {r : HomRel C} [self : CategoryTheory.Congruence r] {X Y : C}
Goal: Equivalence r
-- CategoryTheory.Congruence.compRight
class Congruence : Prop where
    equivalence : ∀ {X Y}, _root_.Equivalence (@r X Y)
    compLeft : ∀ {X Y Z} (f : X ⟶ Y) {g g' : Y ⟶ Z}, r g g' → r (f ≫ g) (f ≫ g')
    compRight : ∀ {X Y Z} {f f' : X ⟶ Y} (g : Y ⟶ Z), r f f' → r (f ≫ g) (f' ≫ g)
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {r : HomRel C} [self : CategoryTheory.Congruence r] {X Y Z : C} {f f' : X ⟶ Y} (g : Y ⟶ Z)
Goal: r f f' → r (CategoryTheory.CategoryStruct.comp f g) (CategoryTheory.CategoryStruct.comp f' g)
-- CategoryTheory.Congruence.compLeft
class Congruence : Prop where
    equivalence : ∀ {X Y}, _root_.Equivalence (@r X Y)
    compLeft : ∀ {X Y Z} (f : X ⟶ Y) {g g' : Y ⟶ Z}, r g g' → r (f ≫ g) (f ≫ g')
    compRight : ∀ {X Y Z} {f f' : X ⟶ Y} (g : Y ⟶ Z), r f f' → r (f ≫ g) (f' ≫ g)
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {r : HomRel C} [self : CategoryTheory.Congruence r] {X Y Z : C} (f : X ⟶ Y) {g g' : Y ⟶ Z}
Goal: r g g' → r (CategoryTheory.CategoryStruct.comp f g) (CategoryTheory.CategoryStruct.comp f g')
-- CategoryTheory.Quotient.CompClosure.of
theorem CompClosure.of {a b : C} (m₁ m₂ : a ⟶ b) (h : r m₁ m₂) : CompClosure r m₁ m₂ 
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_1, u_2} C] (r : HomRel C) {a b : C} (m₁ m₂ : a ⟶ b) (h : r m₁ m₂)
Goal: CategoryTheory.Quotient.CompClosure r m₁ m₂
-- CategoryTheory.Quotient.comp_left
theorem comp_left {a b c : C} (f : a ⟶ b) :
    ∀ (g₁ g₂ : b ⟶ c) (_ : CompClosure r g₁ g₂), CompClosure r (f ≫ g₁) (f ≫ g₂)
  
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_1, u_2} C] (r : HomRel C) {a b c : C} (f : a ⟶ b) (g₁ g₂ : b ⟶ c)
Goal: CategoryTheory.Quotient.CompClosure r g₁ g₂ →
  CategoryTheory.Quotient.CompClosure r (CategoryTheory.CategoryStruct.comp f g₁)
    (CategoryTheory.CategoryStruct.comp f g₂)
-- CategoryTheory.Quotient.comp_right
theorem comp_right {a b c : C} (g : b ⟶ c) :
    ∀ (f₁ f₂ : a ⟶ b) (_ : CompClosure r f₁ f₂), CompClosure r (f₁ ≫ g) (f₂ ≫ g)
  
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_1, u_2} C] (r : HomRel C) {a b c : C} (g : b ⟶ c) (f₁ f₂ : a ⟶ b)
Goal: CategoryTheory.Quotient.CompClosure r f₁ f₂ →
  CategoryTheory.Quotient.CompClosure r (CategoryTheory.CategoryStruct.comp f₁ g)
    (CategoryTheory.CategoryStruct.comp f₂ g)
-- CategoryTheory.Quotient.comp_mk
@[simp]
theorem comp_mk {a b c : Quotient r} (f : a.as ⟶ b.as) (g : b.as ⟶ c.as) :
    comp r (Quot.mk _ f) (Quot.mk _ g) = Quot.mk _ (f ≫ g) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (r : HomRel C) {a b c : CategoryTheory.Quotient r} (f : a.as ⟶ b.as) (g : b.as ⟶ c.as)
Goal: CategoryTheory.Quotient.comp r (Quot.mk (CategoryTheory.Quotient.CompClosure r) f)
    (Quot.mk (CategoryTheory.Quotient.CompClosure r) g) =
  Quot.mk (CategoryTheory.Quotient.CompClosure r) (CategoryTheory.CategoryStruct.comp f g)
-- CategoryTheory.Quotient.induction
protected theorem induction {P : ∀ {a b : Quotient r}, (a ⟶ b) → Prop}
    (h : ∀ {x y : C} (f : x ⟶ y), P ((functor r).map f)) :
    ∀ {a b : Quotient r} (f : a ⟶ b), P f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (r : HomRel C) {P : {a b : CategoryTheory.Quotient r} → (a ⟶ b) → Prop} (h : ∀ {x y : C} (f : x ⟶ y), P ((CategoryTheory.Quotient.functor r).map f)) {a b : CategoryTheory.Quotient r} (f : a ⟶ b)
Goal: P f
-- CategoryTheory.Quotient.sound
protected theorem sound {a b : C} {f₁ f₂ : a ⟶ b} (h : r f₁ f₂) :
    (functor r).map f₁ = (functor r).map f₂ 
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_1, u_2} C] (r : HomRel C) {a b : C} {f₁ f₂ : a ⟶ b} (h : r f₁ f₂)
Goal: (CategoryTheory.Quotient.functor r).map f₁ = (CategoryTheory.Quotient.functor r).map f₂
-- CategoryTheory.Quotient.compClosure_iff_self
lemma compClosure_iff_self [h : Congruence r] {X Y : C} (f g : X ⟶ Y) :
    CompClosure r f g ↔ r f g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (r : HomRel C) [h : CategoryTheory.Congruence r] {X Y : C} (f g : X ⟶ Y)
Goal: CategoryTheory.Quotient.CompClosure r f g ↔ r f g
-- CategoryTheory.Quotient.compClosure_eq_self
@[simp]
theorem compClosure_eq_self [h : Congruence r] :
    CompClosure r = r 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (r : HomRel C) [h : CategoryTheory.Congruence r]
Goal: CategoryTheory.Quotient.CompClosure r = r
-- CategoryTheory.Quotient.functor_map_eq_iff
theorem functor_map_eq_iff [h : Congruence r] {X Y : C} (f f' : X ⟶ Y) :
    (functor r).map f = (functor r).map f' ↔ r f f' 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (r : HomRel C) [h : CategoryTheory.Congruence r] {X Y : C} (f f' : X ⟶ Y)
Goal: (CategoryTheory.Quotient.functor r).map f = (CategoryTheory.Quotient.functor r).map f' ↔ r f f'
-- CategoryTheory.Quotient.lift_spec
theorem lift_spec : functor r ⋙ lift r F H = F 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (r : HomRel C) {D : Type u_3} [CategoryTheory.Category.{u_4, u_3} D] (F : CategoryTheory.Functor C D) (H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂)
Goal: (CategoryTheory.Quotient.functor r).comp (CategoryTheory.Quotient.lift r F H) = F
-- CategoryTheory.Quotient.lift_unique
theorem lift_unique (Φ : Quotient r ⥤ D) (hΦ : functor r ⋙ Φ = F) : Φ = lift r F H 
Arguments: {C : Type u_3} [CategoryTheory.Category.{u_1, u_3} C] (r : HomRel C) {D : Type u_4} [CategoryTheory.Category.{u_2, u_4} D] (F : CategoryTheory.Functor C D) (H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂) (Φ : CategoryTheory.Functor (CategoryTheory.Quotient r) D) (hΦ : (CategoryTheory.Quotient.functor r).comp Φ = F)
Goal: Φ = CategoryTheory.Quotient.lift r F H
-- CategoryTheory.Quotient.lift_unique'
lemma lift_unique' (F₁ F₂ : Quotient r ⥤ D) (h : functor r ⋙ F₁ = functor r ⋙ F₂) :
    F₁ = F₂ 
Arguments: {C : Type u_3} [CategoryTheory.Category.{u_1, u_3} C] (r : HomRel C) {D : Type u_4} [CategoryTheory.Category.{u_2, u_4} D] (F₁ F₂ : CategoryTheory.Functor (CategoryTheory.Quotient r) D) (h : (CategoryTheory.Quotient.functor r).comp F₁ = (CategoryTheory.Quotient.functor r).comp F₂)
Goal: F₁ = F₂
-- CategoryTheory.Quotient.lift.isLift_hom
@[simp]
theorem lift.isLift_hom (X : C) : (lift.isLift r F H).hom.app X = 𝟙 (F.obj X) 
Arguments: {C : Type u_4} [CategoryTheory.Category.{u_3, u_4} C] (r : HomRel C) {D : Type u_2} [CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) (H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂) (X : C)
Goal: (CategoryTheory.Quotient.lift.isLift r F H).hom.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Quotient.lift.isLift_inv
@[simp]
theorem lift.isLift_inv (X : C) : (lift.isLift r F H).inv.app X = 𝟙 (F.obj X) 
Arguments: {C : Type u_4} [CategoryTheory.Category.{u_3, u_4} C] (r : HomRel C) {D : Type u_2} [CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) (H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂) (X : C)
Goal: (CategoryTheory.Quotient.lift.isLift r F H).inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Quotient.lift_obj_functor_obj
theorem lift_obj_functor_obj (X : C) :
    (lift r F H).obj ((functor r).obj X) = F.obj X 
Arguments: {C : Type u_4} [CategoryTheory.Category.{u_2, u_4} C] (r : HomRel C) {D : Type u_1} [CategoryTheory.Category.{u_3, u_1} D] (F : CategoryTheory.Functor C D) (H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂) (X : C)
Goal: (CategoryTheory.Quotient.lift r F H).obj ((CategoryTheory.Quotient.functor r).obj X) = F.obj X
-- CategoryTheory.Quotient.lift_map_functor_map
theorem lift_map_functor_map {X Y : C} (f : X ⟶ Y) :
    (lift r F H).map ((functor r).map f) = F.map f 
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_1, u_2} C] (r : HomRel C) {D : Type u_4} [CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor C D) (H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂) {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Quotient.lift r F H).map ((CategoryTheory.Quotient.functor r).map f) = F.map f
-- CategoryTheory.Quotient.natTrans_ext
lemma natTrans_ext {F G : Quotient r ⥤ D} (τ₁ τ₂ : F ⟶ G)
    (h : whiskerLeft (Quotient.functor r) τ₁ = whiskerLeft (Quotient.functor r) τ₂) : τ₁ = τ₂ 
Arguments: {C : Type u_3} [CategoryTheory.Category.{u_1, u_3} C] {r : HomRel C} {D : Type u_4} [CategoryTheory.Category.{u_2, u_4} D] {F G : CategoryTheory.Functor (CategoryTheory.Quotient r) D} (τ₁ τ₂ : F ⟶ G) (h :
  CategoryTheory.whiskerLeft (CategoryTheory.Quotient.functor r) τ₁ =
    CategoryTheory.whiskerLeft (CategoryTheory.Quotient.functor r) τ₂)
Goal: τ₁ = τ₂
-- CategoryTheory.Quotient.natTransLift_app
@[simp]
lemma natTransLift_app (F G : Quotient r ⥤ D)
    (τ : Quotient.functor r ⋙ F ⟶ Quotient.functor r ⋙ G) (X : C) :
  (natTransLift r τ).app ((Quotient.functor r).obj X) = τ.app X 
Arguments: {C : Type u_3} [CategoryTheory.Category.{u_1, u_3} C] (r : HomRel C) {D : Type u_4} [CategoryTheory.Category.{u_2, u_4} D] (F G : CategoryTheory.Functor (CategoryTheory.Quotient r) D) (τ : (CategoryTheory.Quotient.functor r).comp F ⟶ (CategoryTheory.Quotient.functor r).comp G) (X : C)
Goal: (CategoryTheory.Quotient.natTransLift r τ).app ((CategoryTheory.Quotient.functor r).obj X) = τ.app X
-- CategoryTheory.Quotient.comp_natTransLift
@[reassoc]
lemma comp_natTransLift {F G H : Quotient r ⥤ D}
    (τ : Quotient.functor r ⋙ F ⟶ Quotient.functor r ⋙ G)
    (τ' : Quotient.functor r ⋙ G ⟶ Quotient.functor r ⋙ H) :
    natTransLift r τ ≫ natTransLift r τ' =  natTransLift r (τ ≫ τ') 
Arguments: {C : Type u_3} [CategoryTheory.Category.{u_1, u_3} C] (r : HomRel C) {D : Type u_4} [CategoryTheory.Category.{u_2, u_4} D] {F G H : CategoryTheory.Functor (CategoryTheory.Quotient r) D} (τ : (CategoryTheory.Quotient.functor r).comp F ⟶ (CategoryTheory.Quotient.functor r).comp G) (τ' : (CategoryTheory.Quotient.functor r).comp G ⟶ (CategoryTheory.Quotient.functor r).comp H)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Quotient.natTransLift r τ)
    (CategoryTheory.Quotient.natTransLift r τ') =
  CategoryTheory.Quotient.natTransLift r (CategoryTheory.CategoryStruct.comp τ τ')
-- CategoryTheory.Quotient.natTransLift_id
@[simp]
lemma natTransLift_id (F : Quotient r ⥤ D) :
    natTransLift r (𝟙 (Quotient.functor r ⋙ F)) = 𝟙 _ 
Arguments: {C : Type u_3} [CategoryTheory.Category.{u_1, u_3} C] (r : HomRel C) {D : Type u_4} [CategoryTheory.Category.{u_2, u_4} D] (F : CategoryTheory.Functor (CategoryTheory.Quotient r) D)
Goal: CategoryTheory.Quotient.natTransLift r (CategoryTheory.CategoryStruct.id ((CategoryTheory.Quotient.functor r).comp F)) =
  CategoryTheory.CategoryStruct.id F
-- CategoryTheory.Quotient.natIsoLift_hom
@[simps]
def natIsoLift {F G : Quotient r ⥤ D} (τ : Quotient.functor r ⋙ F ≅ Quotient.functor r ⋙ G) :
    F ≅ G 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (r : HomRel C) {D : Type u_3} [CategoryTheory.Category.{u_4, u_3} D] {F G : CategoryTheory.Functor (CategoryTheory.Quotient r) D} (τ : (CategoryTheory.Quotient.functor r).comp F ≅ (CategoryTheory.Quotient.functor r).comp G)
Goal: (CategoryTheory.Quotient.natIsoLift r τ).hom = CategoryTheory.Quotient.natTransLift r τ.hom
-- CategoryTheory.Quotient.natIsoLift_inv
@[simps]
def natIsoLift {F G : Quotient r ⥤ D} (τ : Quotient.functor r ⋙ F ≅ Quotient.functor r ⋙ G) :
    F ≅ G 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (r : HomRel C) {D : Type u_3} [CategoryTheory.Category.{u_4, u_3} D] {F G : CategoryTheory.Functor (CategoryTheory.Quotient r) D} (τ : (CategoryTheory.Quotient.functor r).comp F ≅ (CategoryTheory.Quotient.functor r).comp G)
Goal: (CategoryTheory.Quotient.natIsoLift r τ).inv = CategoryTheory.Quotient.natTransLift r τ.inv
-- CategoryTheory.Sheaf.composeEquiv_apply_val
@[simps]
def composeEquiv [HasSheafCompose J F] (adj : G ⊣ F) (X : Sheaf J E) (Y : Sheaf J D) :
    ((composeAndSheafify J G).obj X ⟶ Y) ≃ (X ⟶ (sheafCompose J F).obj Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor D E} {G : CategoryTheory.Functor E D} [CategoryTheory.HasWeakSheafify J D] [J.HasSheafCompose F] (adj : G ⊣ F) (X : CategoryTheory.Sheaf J E) (Y : CategoryTheory.Sheaf J D) (η : (CategoryTheory.Sheaf.composeAndSheafify J G).obj X ⟶ Y)
Goal: ((CategoryTheory.Sheaf.composeEquiv J adj X Y) η).val =
  ((CategoryTheory.Adjunction.whiskerRight Cᵒᵖ adj).homEquiv X.val Y.val)
    (CategoryTheory.CategoryStruct.comp
      (CategoryTheory.toSheafify J (((CategoryTheory.whiskeringRight Cᵒᵖ E D).obj G).obj X.val)) η.val)
-- CategoryTheory.Sheaf.composeEquiv_symm_apply_val
@[simps]
def composeEquiv [HasSheafCompose J F] (adj : G ⊣ F) (X : Sheaf J E) (Y : Sheaf J D) :
    ((composeAndSheafify J G).obj X ⟶ Y) ≃ (X ⟶ (sheafCompose J F).obj Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor D E} {G : CategoryTheory.Functor E D} [CategoryTheory.HasWeakSheafify J D] [J.HasSheafCompose F] (adj : G ⊣ F) (X : CategoryTheory.Sheaf J E) (Y : CategoryTheory.Sheaf J D) (γ : X ⟶ (CategoryTheory.sheafCompose J F).obj Y)
Goal: ((CategoryTheory.Sheaf.composeEquiv J adj X Y).symm γ).val =
  CategoryTheory.sheafifyLift J
    (((CategoryTheory.Adjunction.whiskerRight Cᵒᵖ adj).homEquiv ((CategoryTheory.sheafToPresheaf J E).obj X) Y.val).symm
      ((CategoryTheory.sheafToPresheaf J E).map γ))
    ⋯
-- CategoryTheory.Sheaf.adjunction_unit_app_val
@[simps! unit_app_val counit_app_val]
def adjunction [HasSheafCompose J F] (adj : G ⊣ F) :
    composeAndSheafify J G ⊣ sheafCompose J F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor D E} {G : CategoryTheory.Functor E D} [CategoryTheory.HasWeakSheafify J D] [J.HasSheafCompose F] (adj : G ⊣ F) (X : CategoryTheory.Sheaf J E)
Goal: ((CategoryTheory.Sheaf.adjunction J adj).unit.app X).val =
  ((CategoryTheory.Adjunction.whiskerRight Cᵒᵖ adj).homEquiv X.val
      ((CategoryTheory.presheafToSheaf J D).obj (X.val.comp G)).val)
    (CategoryTheory.toSheafify J (X.val.comp G))
-- CategoryTheory.Sheaf.adjunction_counit_app_val
@[simps! unit_app_val counit_app_val]
def adjunction [HasSheafCompose J F] (adj : G ⊣ F) :
    composeAndSheafify J G ⊣ sheafCompose J F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor D E} {G : CategoryTheory.Functor E D} [CategoryTheory.HasWeakSheafify J D] [J.HasSheafCompose F] (adj : G ⊣ F) (Y : CategoryTheory.Sheaf J D)
Goal: ((CategoryTheory.Sheaf.adjunction J adj).counit.app Y).val =
  CategoryTheory.sheafifyLift J
    (((CategoryTheory.Adjunction.whiskerRight Cᵒᵖ adj).homEquiv (Y.val.comp F) Y.val).symm
      (CategoryTheory.CategoryStruct.id (Y.val.comp F)))
    ⋯
-- CategoryTheory.Sheaf.preservesSheafification_of_adjunction
lemma preservesSheafification_of_adjunction (adj : G ⊣ F) :
    J.PreservesSheafification G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor D E} {G : CategoryTheory.Functor E D} (adj : G ⊣ F)
Goal: J.PreservesSheafification G
-- CategoryTheory.Sheaf.adjunctionToTypes_unit_app_val
@[simp]
theorem adjunctionToTypes_unit_app_val {G : Type max v₁ u₁ ⥤ D} (adj : G ⊣ forget D)
    (Y : SheafOfTypes J) :
    ((adjunctionToTypes J adj).unit.app Y).val =
      (adj.whiskerRight _).unit.app ((sheafOfTypesToPresheaf J).obj Y) ≫
        whiskerRight (toSheafify J _) (forget D) 
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) (Y : CategoryTheory.SheafOfTypes J)
Goal: ((CategoryTheory.Sheaf.adjunctionToTypes J adj).unit.app Y).val =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.Adjunction.whiskerRight Cᵒᵖ adj).unit.app ((CategoryTheory.sheafOfTypesToPresheaf J).obj Y))
    (CategoryTheory.whiskerRight
      (CategoryTheory.toSheafify J
        (((CategoryTheory.whiskeringRight Cᵒᵖ (Type (max v₁ u₁)) D).obj G).obj
          ((CategoryTheory.sheafOfTypesToPresheaf J).obj Y)))
      (CategoryTheory.forget D))