ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.sheafComposeNatTrans_fac
lemma sheafComposeNatTrans_fac (P : Cᵒᵖ ⥤ A) :
    adj₂.unit.app (P ⋙ F) ≫
      (sheafToPresheaf J B).map ((sheafComposeNatTrans J F adj₁ adj₂).app P) =
        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) [J.HasSheafCompose F] (P : CategoryTheory.Functor Cᵒᵖ A)
Goal: CategoryTheory.CategoryStruct.comp (adj₂.unit.app (P.comp F))
    ((CategoryTheory.sheafToPresheaf J B).map ((CategoryTheory.sheafComposeNatTrans J F adj₁ adj₂).app P)) =
  CategoryTheory.whiskerRight (adj₁.unit.app P) F
-- CategoryTheory.sheafComposeNatTrans_app_uniq
lemma sheafComposeNatTrans_app_uniq (P : Cᵒᵖ ⥤ A)
    (α : G₂.obj (P ⋙ F) ⟶ (sheafCompose J F).obj (G₁.obj P))
    (hα : adj₂.unit.app (P ⋙ F) ≫ (sheafToPresheaf J B).map α =
        whiskerRight (adj₁.unit.app P) F) :
    α = (sheafComposeNatTrans J F adj₁ adj₂).app P 
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) [J.HasSheafCompose F] (P : CategoryTheory.Functor Cᵒᵖ A) (α : G₂.obj (P.comp F) ⟶ (CategoryTheory.sheafCompose J F).obj (G₁.obj P)) (hα :
  CategoryTheory.CategoryStruct.comp (adj₂.unit.app (P.comp F)) ((CategoryTheory.sheafToPresheaf J B).map α) =
    CategoryTheory.whiskerRight (adj₁.unit.app P) F)
Goal: α = (CategoryTheory.sheafComposeNatTrans J F adj₁ adj₂).app P
-- CategoryTheory.GrothendieckTopology.preservesSheafification_iff_of_adjunctions_of_hasSheafCompose
lemma GrothendieckTopology.preservesSheafification_iff_of_adjunctions_of_hasSheafCompose :
    J.PreservesSheafification F ↔ IsIso (sheafComposeNatTrans J F adj₁ adj₂) 
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) [J.HasSheafCompose F]
Goal: J.PreservesSheafification F ↔ CategoryTheory.IsIso (CategoryTheory.sheafComposeNatTrans J F adj₁ adj₂)
-- CategoryTheory.sheafComposeIso_hom_fac
@[reassoc (attr := simp)]
lemma sheafComposeIso_hom_fac :
    toSheafify J (P ⋙ F) ≫ (sheafifyComposeIso J F P).hom =
      whiskerRight (toSheafify J 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_4, u_1} A] [CategoryTheory.Category.{u_3, u_2} B] (F : CategoryTheory.Functor A B) [CategoryTheory.HasWeakSheafify J A] [CategoryTheory.HasWeakSheafify J B] [J.HasSheafCompose F] [J.PreservesSheafification F] (P : CategoryTheory.Functor Cᵒᵖ A)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.toSheafify J (P.comp F))
    (CategoryTheory.sheafifyComposeIso J F P).hom =
  CategoryTheory.whiskerRight (CategoryTheory.toSheafify J P) F
-- CategoryTheory.sheafComposeIso_inv_fac
@[reassoc (attr := simp)]
lemma sheafComposeIso_inv_fac :
    whiskerRight (toSheafify J P) F ≫ (sheafifyComposeIso J F P).inv =
      toSheafify J (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_4, u_1} A] [CategoryTheory.Category.{u_3, u_2} B] (F : CategoryTheory.Functor A B) [CategoryTheory.HasWeakSheafify J A] [CategoryTheory.HasWeakSheafify J B] [J.HasSheafCompose F] [J.PreservesSheafification F] (P : CategoryTheory.Functor Cᵒᵖ A)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerRight (CategoryTheory.toSheafify J P) F)
    (CategoryTheory.sheafifyComposeIso J F P).inv =
  CategoryTheory.toSheafify J (P.comp F)
-- CategoryTheory.GrothendieckTopology.sheafToPresheaf_map_sheafComposeNatTrans_eq_sheafifyCompIso_inv
lemma sheafToPresheaf_map_sheafComposeNatTrans_eq_sheafifyCompIso_inv (P : Cᵒᵖ ⥤ D) :
    (sheafToPresheaf J E).map
      ((sheafComposeNatTrans J F (plusPlusAdjunction J D) (plusPlusAdjunction J E)).app P) =
      (sheafifyCompIso J F P).inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u_3} {E : Type u_4} [CategoryTheory.Category.{max v u, u_3} D] [CategoryTheory.Category.{max v u, u_4} E] (F : CategoryTheory.Functor D E) [∀ (α β : Type (max v u)) (fst snd : β → α),
    CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Limits.WalkingMulticospan fst snd) D] [∀ (α β : Type (max v u)) (fst snd : β → α),
    CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Limits.WalkingMulticospan fst snd) E] [∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (J.Cover X)ᵒᵖ D] [∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (J.Cover X)ᵒᵖ E] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfShape (J.Cover X)ᵒᵖ F] [(X : C) →
    (W : J.Cover X) →
      (P : CategoryTheory.Functor Cᵒᵖ D) → CategoryTheory.Limits.PreservesLimit (W.index P).multicospan F] [CategoryTheory.ConcreteCategory D] [CategoryTheory.ConcreteCategory E] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfShape (J.Cover X)ᵒᵖ (CategoryTheory.forget D)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfShape (J.Cover X)ᵒᵖ (CategoryTheory.forget E)] [CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget D)] [CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget E)] [(CategoryTheory.forget D).ReflectsIsomorphisms] [(CategoryTheory.forget E).ReflectsIsomorphisms] (P : CategoryTheory.Functor Cᵒᵖ D)
Goal: (CategoryTheory.sheafToPresheaf J E).map
    ((CategoryTheory.sheafComposeNatTrans J F (CategoryTheory.plusPlusAdjunction J D)
          (CategoryTheory.plusPlusAdjunction J E)).app
      P) =
  (J.sheafifyCompIso F P).inv
-- CategoryTheory.types_hom
theorem types_hom {α β : Type u} : (α ⟶ β) = (α → β) 
Arguments: {α β : Type u}
Goal: (α ⟶ β) = (α → β)
-- CategoryTheory.types_ext
@[ext] theorem types_ext {α β : Type u} (f g : α ⟶ β) (h : ∀ a : α, f a = g a) : f = g 
Arguments: {α β : Type u} (f g : α ⟶ β) (h : ∀ (a : α), f a = g a)
Goal: f = g
-- CategoryTheory.types_id
theorem types_id (X : Type u) : 𝟙 X = id 
Arguments: (X : Type u)
Goal: CategoryTheory.CategoryStruct.id X = id
-- CategoryTheory.types_comp
theorem types_comp {X Y Z : Type u} (f : X ⟶ Y) (g : Y ⟶ Z) : f ≫ g = g ∘ f 
Arguments: {X Y Z : Type u} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: CategoryTheory.CategoryStruct.comp f g = g ∘ f
-- CategoryTheory.types_id_apply
@[simp]
theorem types_id_apply (X : Type u) (x : X) : (𝟙 X : X → X) x = x 
Arguments: (X : Type u) (x : X)
Goal: CategoryTheory.CategoryStruct.id X x = x
-- CategoryTheory.types_comp_apply
@[simp]
theorem types_comp_apply {X Y Z : Type u} (f : X ⟶ Y) (g : Y ⟶ Z) (x : X) : (f ≫ g) x = g (f x) 
Arguments: {X Y Z : Type u} (f : X ⟶ Y) (g : Y ⟶ Z) (x : X)
Goal: CategoryTheory.CategoryStruct.comp f g x = g (f x)
-- CategoryTheory.hom_inv_id_apply
@[simp]
theorem hom_inv_id_apply {X Y : Type u} (f : X ≅ Y) (x : X) : f.inv (f.hom x) = x 
Arguments: {X Y : Type u} (f : X ≅ Y) (x : X)
Goal: f.inv (f.hom x) = x
-- CategoryTheory.inv_hom_id_apply
@[simp]
theorem inv_hom_id_apply {X Y : Type u} (f : X ≅ Y) (y : Y) : f.hom (f.inv y) = y 
Arguments: {X Y : Type u} (f : X ≅ Y) (y : Y)
Goal: f.hom (f.inv y) = y
-- CategoryTheory.Functor.sections_property
@[simp]
lemma sections_property {F : J ⥤ Type w} (s : (F.sections : Type _))
    {j j' : J} (f : j ⟶ j') : F.map f (s.val j) = s.val j' 
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w)} (s : ↑F.sections) {j j' : J} (f : j ⟶ j')
Goal: F.map f (↑s j) = ↑s j'
-- CategoryTheory.Functor.sections_ext_iff
lemma sections_ext_iff {F : J ⥤ Type w} {x y : F.sections} : x = y ↔ ∀ j, x.val j = y.val j 
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w)} {x y : ↑F.sections}
Goal: x = y ↔ ∀ (j : J), ↑x j = ↑y j
-- CategoryTheory.Functor.sectionsFunctor_obj
@[simps]
def sectionsFunctor : (J ⥤ Type w) ⥤ Type max u w 
Arguments: (J : Type u) [CategoryTheory.Category.{v, u} J] (F : CategoryTheory.Functor J (Type w))
Goal: (CategoryTheory.Functor.sectionsFunctor J).obj F = ↑F.sections
-- CategoryTheory.Functor.sectionsFunctor_map_coe
@[simps]
def sectionsFunctor : (J ⥤ Type w) ⥤ Type max u w 
Arguments: (J : Type u) [CategoryTheory.Category.{v, u} J] {F G : CategoryTheory.Functor J (Type w)} (φ : F ⟶ G) (x : ↑F.sections) (j : J)
Goal: ↑((CategoryTheory.Functor.sectionsFunctor J).map φ x) j = φ.app j (↑x j)
-- CategoryTheory.FunctorToTypes.map_comp_apply
@[simp]
theorem map_comp_apply (f : X ⟶ Y) (g : Y ⟶ Z) (a : F.obj X) :
    (F.map (f ≫ g)) a = (F.map g) ((F.map f) a) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (a : F.obj X)
Goal: F.map (CategoryTheory.CategoryStruct.comp f g) a = F.map g (F.map f a)
-- CategoryTheory.FunctorToTypes.map_id_apply
@[simp]
theorem map_id_apply (a : F.obj X) : (F.map (𝟙 X)) a = a 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) {X : C} (a : F.obj X)
Goal: F.map (CategoryTheory.CategoryStruct.id X) a = a
-- CategoryTheory.FunctorToTypes.naturality
theorem naturality (f : X ⟶ Y) (x : F.obj X) : σ.app Y ((F.map f) x) = (G.map f) (σ.app X x) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) {X Y : C} (σ : F ⟶ G) (f : X ⟶ Y) (x : F.obj X)
Goal: σ.app Y (F.map f x) = G.map f (σ.app X x)
-- CategoryTheory.FunctorToTypes.comp
@[simp]
theorem comp (x : F.obj X) : (σ ≫ τ).app X x = τ.app X (σ.app X x) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G H : CategoryTheory.Functor C (Type w)) {X : C} (σ : F ⟶ G) (τ : G ⟶ H) (x : F.obj X)
Goal: (CategoryTheory.CategoryStruct.comp σ τ).app X x = τ.app X (σ.app X x)
-- CategoryTheory.FunctorToTypes.eqToHom_map_comp_apply
@[simp]
theorem eqToHom_map_comp_apply (p : X = Y) (q : Y = Z) (x : F.obj X) :
    F.map (eqToHom q) (F.map (eqToHom p) x) = F.map (eqToHom <| p.trans q) x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) {X Y Z : C} (p : X = Y) (q : Y = Z) (x : F.obj X)
Goal: F.map (CategoryTheory.eqToHom q) (F.map (CategoryTheory.eqToHom p) x) = F.map (CategoryTheory.eqToHom ⋯) x
-- CategoryTheory.FunctorToTypes.hcomp
@[simp]
theorem hcomp (x : (I ⋙ F).obj W) : (ρ ◫ σ).app W x = (G.map (ρ.app W)) (σ.app (I.obj W) x) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (σ : F ⟶ G) {D : Type u'} [𝒟 : CategoryTheory.Category.{u', u'} D] (I J : CategoryTheory.Functor D C) (ρ : I ⟶ J) {W : D} (x : (I.comp F).obj W)
Goal: (ρ ◫ σ).app W x = G.map (ρ.app W) (σ.app (I.obj W) x)
-- CategoryTheory.FunctorToTypes.map_inv_map_hom_apply
@[simp]
theorem map_inv_map_hom_apply (f : X ≅ Y) (x : F.obj X) : F.map f.inv (F.map f.hom x) = x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) {X Y : C} (f : X ≅ Y) (x : F.obj X)
Goal: F.map f.inv (F.map f.hom x) = x
-- CategoryTheory.FunctorToTypes.map_hom_map_inv_apply
@[simp]
theorem map_hom_map_inv_apply (f : X ≅ Y) (y : F.obj Y) : F.map f.hom (F.map f.inv y) = y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) {X Y : C} (f : X ≅ Y) (y : F.obj Y)
Goal: F.map f.hom (F.map f.inv y) = y
-- CategoryTheory.FunctorToTypes.hom_inv_id_app_apply
@[simp]
theorem hom_inv_id_app_apply (α : F ≅ G) (X) (x) : α.inv.app X (α.hom.app X x) = x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (α : F ≅ G) (X : C) (x : F.obj X)
Goal: α.inv.app X (α.hom.app X x) = x
-- CategoryTheory.FunctorToTypes.inv_hom_id_app_apply
@[simp]
theorem inv_hom_id_app_apply (α : F ≅ G) (X) (x) : α.hom.app X (α.inv.app X x) = x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (α : F ≅ G) (X : C) (x : G.obj X)
Goal: α.hom.app X (α.inv.app X x) = x
-- CategoryTheory.uliftFunctor_obj
@[simp]
theorem uliftFunctor_obj {X : Type u} : uliftFunctor.obj.{v} X = ULift.{v} X 
Arguments: {X : Type u}
Goal: CategoryTheory.uliftFunctor.{v, u}.obj X = ULift.{v, u} X
-- CategoryTheory.uliftFunctor_map
@[simp]
theorem uliftFunctor_map {X Y : Type u} (f : X ⟶ Y) (x : ULift.{v} X) :
    uliftFunctor.map f x = ULift.up (f x.down) 
Arguments: {X Y : Type u} (f : X ⟶ Y) (x : ULift.{v, u} X)
Goal: CategoryTheory.uliftFunctor.{v, u}.map f x = { down := f x.down }
-- CategoryTheory.homOfElement_eq_iff
theorem homOfElement_eq_iff {X : Type u} (x y : X) : homOfElement x = homOfElement y ↔ x = y 
Arguments: {X : Type u} (x y : X)
Goal: CategoryTheory.homOfElement x = CategoryTheory.homOfElement y ↔ x = y
-- CategoryTheory.mono_iff_injective
theorem mono_iff_injective {X Y : Type u} (f : X ⟶ Y) : Mono f ↔ Function.Injective f 
Arguments: {X Y : Type u} (f : X ⟶ Y)
Goal: CategoryTheory.Mono f ↔ Function.Injective f
-- CategoryTheory.injective_of_mono
theorem injective_of_mono {X Y : Type u} (f : X ⟶ Y) [hf : Mono f] : Function.Injective f 
Arguments: {X Y : Type u} (f : X ⟶ Y) [hf : CategoryTheory.Mono f]
Goal: Function.Injective f
-- CategoryTheory.epi_iff_surjective
theorem epi_iff_surjective {X Y : Type u} (f : X ⟶ Y) : Epi f ↔ Function.Surjective f 
Arguments: {X Y : Type u} (f : X ⟶ Y)
Goal: CategoryTheory.Epi f ↔ Function.Surjective f
-- CategoryTheory.surjective_of_epi
theorem surjective_of_epi {X Y : Type u} (f : X ⟶ Y) [hf : Epi f] : Function.Surjective f 
Arguments: {X Y : Type u} (f : X ⟶ Y) [hf : CategoryTheory.Epi f]
Goal: Function.Surjective f
-- CategoryTheory.ofTypeFunctor_obj
@[simp]
theorem ofTypeFunctor_obj : (ofTypeFunctor m).obj = m 
Arguments: (m : Type u → Type v) [Functor m] [LawfulFunctor m]
Goal: (CategoryTheory.ofTypeFunctor m).obj = m
-- CategoryTheory.ofTypeFunctor_map
@[simp]
theorem ofTypeFunctor_map {α β} (f : α → β) :
    (ofTypeFunctor m).map f = (Functor.map f : m α → m β) 
Arguments: (m : Type u → Type v) [Functor m] [LawfulFunctor m] {α β : Type u} (f : α → β)
Goal: (CategoryTheory.ofTypeFunctor m).map f = Functor.map f
-- Equiv.toIso_hom
@[simp]
theorem toIso_hom {e : X ≃ Y} : e.toIso.hom = e 
Arguments: {X Y : Type u} {e : X ≃ Y}
Goal: e.toIso.hom = ⇑e
-- Equiv.toIso_inv
@[simp]
theorem toIso_inv {e : X ≃ Y} : e.toIso.inv = e.symm 
Arguments: {X Y : Type u} {e : X ≃ Y}
Goal: e.toIso.inv = ⇑e.symm
-- CategoryTheory.Iso.toEquiv_fun
@[simp]
theorem toEquiv_fun (i : X ≅ Y) : (i.toEquiv : X → Y) = i.hom 
Arguments: {X Y : Type u} (i : X ≅ Y)
Goal: ⇑i.toEquiv = i.hom
-- CategoryTheory.Iso.toEquiv_symm_fun
@[simp]
theorem toEquiv_symm_fun (i : X ≅ Y) : (i.toEquiv.symm : Y → X) = i.inv 
Arguments: {X Y : Type u} (i : X ≅ Y)
Goal: ⇑i.toEquiv.symm = i.inv
-- CategoryTheory.Iso.toEquiv_id
@[simp]
theorem toEquiv_id (X : Type u) : (Iso.refl X).toEquiv = Equiv.refl X 
Arguments: (X : Type u)
Goal: (CategoryTheory.Iso.refl X).toEquiv = Equiv.refl X
-- CategoryTheory.Iso.toEquiv_comp
@[simp]
theorem toEquiv_comp {X Y Z : Type u} (f : X ≅ Y) (g : Y ≅ Z) :
    (f ≪≫ g).toEquiv = f.toEquiv.trans g.toEquiv 
Arguments: {X Y Z : Type u} (f : X ≅ Y) (g : Y ≅ Z)
Goal: (f ≪≫ g).toEquiv = f.toEquiv.trans g.toEquiv
-- CategoryTheory.isIso_iff_bijective
theorem isIso_iff_bijective {X Y : Type u} (f : X ⟶ Y) : IsIso f ↔ Function.Bijective f 
Arguments: {X Y : Type u} (f : X ⟶ Y)
Goal: CategoryTheory.IsIso f ↔ Function.Bijective f
-- equivIsoIso_inv
@[simps]
def equivIsoIso {X Y : Type u} : X ≃ Y ≅ X ≅ Y 
Arguments: {X Y : Type u} (i : X ≅ Y)
Goal: equivIsoIso.inv i = i.toEquiv
-- equivIsoIso_hom
@[simps]
def equivIsoIso {X Y : Type u} : X ≃ Y ≅ X ≅ Y 
Arguments: {X Y : Type u} (e : X ≃ Y)
Goal: equivIsoIso.hom e = e.toIso
-- equivEquivIso_hom
@[simp]
theorem equivEquivIso_hom {X Y : Type u} (e : X ≃ Y) : equivEquivIso e = e.toIso 
Arguments: {X Y : Type u} (e : X ≃ Y)
Goal: equivEquivIso e = e.toIso
-- equivEquivIso_inv
@[simp]
theorem equivEquivIso_inv {X Y : Type u} (e : X ≅ Y) : equivEquivIso.symm e = e.toEquiv 
Arguments: {X Y : Type u} (e : X ≅ Y)
Goal: equivEquivIso.symm e = e.toEquiv
-- CategoryTheory.Functor.IsCocontinuous.cover_lift
-- Porting note(#5171): removed `@[nolint has_nonempty_instance]`
class Functor.IsCocontinuous : Prop where
  cover_lift : ∀ {U : C} {S : Sieve (G.obj U)} (_ : S ∈ K (G.obj U)), S.functorPullback G ∈ J U
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_5, u_2} D] {G : C ⥤ D} {J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D} [self : G.IsCocontinuous J K] {U : C} {S : CategoryTheory.Sieve (G.obj U)}
Goal: S ∈ K.sieves (G.obj U) → CategoryTheory.Sieve.functorPullback G S ∈ J.sieves U
-- CategoryTheory.Functor.cover_lift
lemma Functor.cover_lift [G.IsCocontinuous J K] {U : C} {S : Sieve (G.obj U)}
    (hS : S ∈ K (G.obj U)) : S.functorPullback G ∈ J U 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_5, u_2} D] (G : C ⥤ D) (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [G.IsCocontinuous J K] {U : C} {S : CategoryTheory.Sieve (G.obj U)} (hS : S ∈ K.sieves (G.obj U))
Goal: CategoryTheory.Sieve.functorPullback G S ∈ J.sieves U
-- CategoryTheory.isCocontinuous_comp
theorem isCocontinuous_comp [G.IsCocontinuous J K] [G'.IsCocontinuous K L] :
    (G ⋙ G').IsCocontinuous J L 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_5, u_2} D] {E : Type u_3} [CategoryTheory.Category.{u_6, u_3} E] (G : C ⥤ D) (G' : D ⥤ E) (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) {L : CategoryTheory.GrothendieckTopology E} [G.IsCocontinuous J K] [G'.IsCocontinuous K L]
Goal: (G ⋙ G').IsCocontinuous J L
-- CategoryTheory.RanIsSheafOfIsCocontinuous.liftAux_map
lemma liftAux_map {Y : C} (f : G.obj Y ⟶ X) {W : C} (g : W ⟶ Y) (i : S.Arrow)
    (h : G.obj W ⟶ i.Y) (w : h ≫ i.f = G.map g ≫ f) :
    liftAux hF α s f ≫ F.map g.op = s.ι i ≫ R.map h.op ≫ α.app _ 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] {G : C ⥤ D} {A : Type w} [CategoryTheory.Category.{w', w} A] {J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D} [G.IsCocontinuous J K] {F : Cᵒᵖ ⥤ A} (hF : CategoryTheory.Presheaf.IsSheaf J F) {R : Dᵒᵖ ⥤ A} (α : G.op ⋙ R ⟶ F) {X : D} {S : K.Cover X} (s : CategoryTheory.Limits.Multifork (S.index R)) {Y : C} (f : G.obj Y ⟶ X) {W : C} (g : W ⟶ Y) (i : S.Arrow) (h : G.obj W ⟶ i.Y) (w : h ≫ i.f = G.map g ≫ f)
Goal: CategoryTheory.RanIsSheafOfIsCocontinuous.liftAux hF α s f ≫ F.map g.op = s.ι i ≫ R.map h.op ≫ α.app (Opposite.op W)
-- CategoryTheory.RanIsSheafOfIsCocontinuous.liftAux_map'
lemma liftAux_map' {Y Y' : C} (f : G.obj Y ⟶ X) (f' : G.obj Y' ⟶ X) {W : C}
    (a : W ⟶ Y) (b : W ⟶ Y') (w : G.map a ≫ f = G.map b ≫ f') :
    liftAux hF α s f ≫ F.map a.op = liftAux hF α s f' ≫ F.map b.op 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] {G : C ⥤ D} {A : Type w} [CategoryTheory.Category.{w', w} A] {J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D} [G.IsCocontinuous J K] {F : Cᵒᵖ ⥤ A} (hF : CategoryTheory.Presheaf.IsSheaf J F) {R : Dᵒᵖ ⥤ A} (α : G.op ⋙ R ⟶ F) {X : D} {S : K.Cover X} (s : CategoryTheory.Limits.Multifork (S.index R)) {Y Y' : C} (f : G.obj Y ⟶ X) (f' : G.obj Y' ⟶ X) {W : C} (a : W ⟶ Y) (b : W ⟶ Y') (w : G.map a ≫ f = G.map b ≫ f')
Goal: CategoryTheory.RanIsSheafOfIsCocontinuous.liftAux hF α s f ≫ F.map a.op =
  CategoryTheory.RanIsSheafOfIsCocontinuous.liftAux hF α s f' ≫ F.map b.op
-- CategoryTheory.RanIsSheafOfIsCocontinuous.fac'
lemma fac' (j : StructuredArrow (op X) G.op) :
    lift hF hR s ≫ R.map j.hom ≫ α.app j.right = liftAux hF α s j.hom.unop 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] {G : C ⥤ D} {A : Type w} [CategoryTheory.Category.{w', w} A] {J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D} [G.IsCocontinuous J K] {F : Cᵒᵖ ⥤ A} (hF : CategoryTheory.Presheaf.IsSheaf J F) {R : Dᵒᵖ ⥤ A} {α : G.op ⋙ R ⟶ F} (hR : (CategoryTheory.Functor.RightExtension.mk R α).IsPointwiseRightKanExtension) {X : D} {S : K.Cover X} (s : CategoryTheory.Limits.Multifork (S.index R)) (j : CategoryTheory.StructuredArrow (Opposite.op X) G.op)
Goal: CategoryTheory.RanIsSheafOfIsCocontinuous.lift hF hR s ≫ R.map j.hom ≫ α.app j.right =
  CategoryTheory.RanIsSheafOfIsCocontinuous.liftAux hF α s j.hom.unop
-- CategoryTheory.RanIsSheafOfIsCocontinuous.fac
@[reassoc (attr := simp)]
lemma fac (i : S.Arrow) : lift hF hR s ≫ R.map i.f.op = s.ι i 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] {G : C ⥤ D} {A : Type w} [CategoryTheory.Category.{w', w} A] {J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D} [G.IsCocontinuous J K] {F : Cᵒᵖ ⥤ A} (hF : CategoryTheory.Presheaf.IsSheaf J F) {R : Dᵒᵖ ⥤ A} {α : G.op ⋙ R ⟶ F} (hR : (CategoryTheory.Functor.RightExtension.mk R α).IsPointwiseRightKanExtension) {X : D} {S : K.Cover X} (s : CategoryTheory.Limits.Multifork (S.index R)) (i : S.Arrow)
Goal: CategoryTheory.RanIsSheafOfIsCocontinuous.lift hF hR s ≫ R.map i.f.op = s.ι i
-- CategoryTheory.RanIsSheafOfIsCocontinuous.hom_ext
lemma hom_ext {W : A} {f g : W ⟶ R.obj (op X)}
    (h : ∀ (i : S.Arrow), f ≫ R.map i.f.op = g ≫ R.map i.f.op) : f = g 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] {G : C ⥤ D} {A : Type w} [CategoryTheory.Category.{w', w} A] {J : CategoryTheory.GrothendieckTopology C} (K : CategoryTheory.GrothendieckTopology D) [G.IsCocontinuous J K] {F : Cᵒᵖ ⥤ A} (hF : CategoryTheory.Presheaf.IsSheaf J F) {R : Dᵒᵖ ⥤ A} {α : G.op ⋙ R ⟶ F} (hR : (CategoryTheory.Functor.RightExtension.mk R α).IsPointwiseRightKanExtension) {X : D} {S : K.Cover X} {W : A} {f g : W ⟶ R.obj (Opposite.op X)} (h : ∀ (i : S.Arrow), f ≫ R.map i.f.op = g ≫ R.map i.f.op)
Goal: f = g
-- CategoryTheory.ran_isSheaf_of_isCocontinuous
theorem ran_isSheaf_of_isCocontinuous (ℱ : Sheaf J A) :
    Presheaf.IsSheaf K (G.op.ran.obj ℱ.val) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] (G : C ⥤ D) {A : Type w} [CategoryTheory.Category.{w', w} A] {J : CategoryTheory.GrothendieckTopology C} (K : CategoryTheory.GrothendieckTopology D) [G.IsCocontinuous J K] [∀ (F : Cᵒᵖ ⥤ A), G.op.HasPointwiseRightKanExtension F] (ℱ : CategoryTheory.Sheaf J A)
Goal: CategoryTheory.Presheaf.IsSheaf K (G.op.ran.obj ℱ.val)