ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Iso.inverseCompIso_hom_app
@[simps!]
def inverseCompIso {G : C ≌ D} (i : F ≅ G.functor ⋙ H) : G.inverse ⋙ F ≅ H 
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 E} {H : CategoryTheory.Functor D E} {G : C ≌ D} (i : F ≅ G.functor.comp H) (X : D)
Goal: i.inverseCompIso.hom.app X =
  CategoryTheory.CategoryStruct.comp (i.hom.app (G.inverse.obj X)) (H.map (G.counitIso.hom.app X))
-- CategoryTheory.Iso.isoInverseComp_hom_app
@[simps!]
def isoInverseComp {G : C ≌ D} (i : G.functor ⋙ H ≅ F) : H ≅ G.inverse ⋙ F 
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 E} {H : CategoryTheory.Functor D E} {G : C ≌ D} (i : G.functor.comp H ≅ F) (X : D)
Goal: i.isoInverseComp.hom.app X =
  CategoryTheory.CategoryStruct.comp (H.map (G.counitIso.inv.app X)) (i.hom.app (G.inverse.obj X))
-- CategoryTheory.Iso.isoInverseComp_inv_app
@[simps!]
def isoInverseComp {G : C ≌ D} (i : G.functor ⋙ H ≅ F) : H ≅ G.inverse ⋙ F 
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 E} {H : CategoryTheory.Functor D E} {G : C ≌ D} (i : G.functor.comp H ≅ F) (X : D)
Goal: i.isoInverseComp.inv.app X =
  CategoryTheory.CategoryStruct.comp (i.inv.app (G.inverse.obj X)) (H.map (G.counitIso.hom.app X))
-- CategoryTheory.coherentTopology.mem_sieves_of_hasEffectiveEpiFamily
theorem coherentTopology.mem_sieves_of_hasEffectiveEpiFamily (S : Sieve X) :
    (∃ (α : Type) (_ : Finite α) (Y : α → C) (π : (a : α) → (Y a ⟶ X)),
      EffectiveEpiFamily Y π ∧ (∀ a : α, (S.arrows) (π a)) ) →
        (S ∈ GrothendieckTopology.sieves (coherentTopology C) X) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Precoherent C] {X : C} (S : CategoryTheory.Sieve X)
Goal: (∃ α, ∃ (_ : Finite α), ∃ Y π, CategoryTheory.EffectiveEpiFamily Y π ∧ ∀ (a : α), S.arrows (π a)) →
  S ∈ (CategoryTheory.coherentTopology C).sieves X
-- CategoryTheory.EffectiveEpiFamily.transitive_of_finite
theorem EffectiveEpiFamily.transitive_of_finite {α : Type} [Finite α] {Y : α → C}
    (π : (a : α) → (Y a ⟶ X)) (h : EffectiveEpiFamily Y π) {β : α → Type} [∀ (a : α), Finite (β a)]
    {Y_n : (a : α) → β a → C} (π_n : (a : α) → (b : β a) → (Y_n a b ⟶ Y a))
    (H : ∀ a, EffectiveEpiFamily (Y_n a) (π_n a)) :
    EffectiveEpiFamily
      (fun (c : Σ a, β a) => Y_n c.fst c.snd) (fun c => π_n c.fst c.snd ≫ π c.fst) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Precoherent C] {X : C} {α : Type} [Finite α] {Y : α → C} (π : (a : α) → Y a ⟶ X) (h : CategoryTheory.EffectiveEpiFamily Y π) {β : α → Type} [∀ (a : α), Finite (β a)] {Y_n : (a : α) → β a → C} (π_n : (a : α) → (b : β a) → Y_n a b ⟶ Y a) (H : ∀ (a : α), CategoryTheory.EffectiveEpiFamily (Y_n a) (π_n a))
Goal: CategoryTheory.EffectiveEpiFamily (fun c => Y_n c.fst c.snd) fun c =>
  CategoryTheory.CategoryStruct.comp (π_n c.fst c.snd) (π c.fst)
-- CategoryTheory.coherentTopology.mem_sieves_iff_hasEffectiveEpiFamily
theorem coherentTopology.mem_sieves_iff_hasEffectiveEpiFamily (S : Sieve X) :
    (S ∈ GrothendieckTopology.sieves (coherentTopology C) X) ↔
    (∃ (α : Type) (_ : Finite α) (Y : α → C) (π : (a : α) → (Y a ⟶ X)),
        EffectiveEpiFamily Y π ∧ (∀ a : α, (S.arrows) (π a)) )  
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Precoherent C] {X : C} (S : CategoryTheory.Sieve X)
Goal: S ∈ (CategoryTheory.coherentTopology C).sieves X ↔
  ∃ α, ∃ (_ : Finite α), ∃ Y π, CategoryTheory.EffectiveEpiFamily Y π ∧ ∀ (a : α), S.arrows (π a)
-- CategoryTheory.Functor.reflects_preregular
lemma Functor.reflects_preregular : Preregular C 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] (F : CategoryTheory.Functor C D) [F.PreservesEffectiveEpis] [F.ReflectsEffectiveEpis] [F.EffectivelyEnough] [CategoryTheory.Preregular D] [F.Full] [F.Faithful]
Goal: CategoryTheory.Preregular C
-- CategoryTheory.TwoSquare.whiskerVertical_app
@[simps!]
def whiskerVertical (α : L ⟶ L') (β : R' ⟶ R) :
    TwoSquare T L' R' B 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {D₁ : Type u_4} {D₂ : Type u_5} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_4} D₁] [CategoryTheory.Category.{u_10, u_5} D₂] {T : CategoryTheory.Functor C₁ D₁} {L : CategoryTheory.Functor C₁ C₂} {R : CategoryTheory.Functor D₁ D₂} {B : CategoryTheory.Functor C₂ D₂} (w : CategoryTheory.TwoSquare T L R B) {L' : CategoryTheory.Functor C₁ C₂} {R' : CategoryTheory.Functor D₁ D₂} (α : L ⟶ L') (β : R' ⟶ R) (X : C₁)
Goal: (w.whiskerVertical α β).app X =
  CategoryTheory.CategoryStruct.comp (β.app (T.obj X)) (CategoryTheory.CategoryStruct.comp (w.app X) (B.map (α.app X)))
-- CategoryTheory.TwoSquare.GuitartExact.whiskerVertical
lemma whiskerVertical [w.GuitartExact] (α : L ≅ L') (β : R ≅ R') :
    (w.whiskerVertical α.hom β.inv).GuitartExact 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {D₁ : Type u_4} {D₂ : Type u_5} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_9, u_2} C₂] [CategoryTheory.Category.{u_8, u_4} D₁] [CategoryTheory.Category.{u_10, u_5} D₂] {T : CategoryTheory.Functor C₁ D₁} {L : CategoryTheory.Functor C₁ C₂} {R : CategoryTheory.Functor D₁ D₂} {B : CategoryTheory.Functor C₂ D₂} (w : CategoryTheory.TwoSquare T L R B) {L' : CategoryTheory.Functor C₁ C₂} {R' : CategoryTheory.Functor D₁ D₂} [w.GuitartExact] (α : L ≅ L') (β : R ≅ R')
Goal: (w.whiskerVertical α.hom β.inv).GuitartExact
-- CategoryTheory.TwoSquare.GuitartExact.whiskerVertical_iff
@[simp]
lemma whiskerVertical_iff (α : L ≅ L') (β : R ≅ R') :
    (w.whiskerVertical α.hom β.inv).GuitartExact ↔ w.GuitartExact 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {D₁ : Type u_4} {D₂ : Type u_5} [CategoryTheory.Category.{u_8, u_1} C₁] [CategoryTheory.Category.{u_7, u_2} C₂] [CategoryTheory.Category.{u_10, u_4} D₁] [CategoryTheory.Category.{u_9, u_5} D₂] {T : CategoryTheory.Functor C₁ D₁} {L : CategoryTheory.Functor C₁ C₂} {R : CategoryTheory.Functor D₁ D₂} {B : CategoryTheory.Functor C₂ D₂} (w : CategoryTheory.TwoSquare T L R B) {L' : CategoryTheory.Functor C₁ C₂} {R' : CategoryTheory.Functor D₁ D₂} (α : L ≅ L') (β : R ≅ R')
Goal: (w.whiskerVertical α.hom β.inv).GuitartExact ↔ w.GuitartExact
-- CategoryTheory.TwoSquare.vComp_app
@[simps!]
def vComp : TwoSquare H₁ (L₁ ⋙ L₂) (R₁ ⋙ R₂) H₃ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {D₁ : Type u_4} {D₂ : Type u_5} {D₃ : Type u_6} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} D₁] [CategoryTheory.Category.{u_11, u_5} D₂] [CategoryTheory.Category.{u_12, u_6} D₃] {H₁ : CategoryTheory.Functor C₁ D₁} {L₁ : CategoryTheory.Functor C₁ C₂} {R₁ : CategoryTheory.Functor D₁ D₂} {H₂ : CategoryTheory.Functor C₂ D₂} (w : CategoryTheory.TwoSquare H₁ L₁ R₁ H₂) {L₂ : CategoryTheory.Functor C₂ C₃} {R₂ : CategoryTheory.Functor D₂ D₃} {H₃ : CategoryTheory.Functor C₃ D₃} (w' : CategoryTheory.TwoSquare H₂ L₂ R₂ H₃) (X : C₁)
Goal: (w.vComp w').app X = CategoryTheory.CategoryStruct.comp (R₂.map (w.app X)) (w'.app (L₁.obj X))
-- CategoryTheory.TwoSquare.vComp'_app
@[simps!]
def vComp' {L₁₂ : C₁ ⥤ C₃} {R₁₂ : D₁ ⥤ D₃} (eL : L₁ ⋙ L₂ ≅ L₁₂)
    (eR : R₁ ⋙ R₂ ≅ R₁₂) : TwoSquare H₁ L₁₂ R₁₂ H₃ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {D₁ : Type u_4} {D₂ : Type u_5} {D₃ : Type u_6} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} D₁] [CategoryTheory.Category.{u_11, u_5} D₂] [CategoryTheory.Category.{u_12, u_6} D₃] {H₁ : CategoryTheory.Functor C₁ D₁} {L₁ : CategoryTheory.Functor C₁ C₂} {R₁ : CategoryTheory.Functor D₁ D₂} {H₂ : CategoryTheory.Functor C₂ D₂} (w : CategoryTheory.TwoSquare H₁ L₁ R₁ H₂) {L₂ : CategoryTheory.Functor C₂ C₃} {R₂ : CategoryTheory.Functor D₂ D₃} {H₃ : CategoryTheory.Functor C₃ D₃} (w' : CategoryTheory.TwoSquare H₂ L₂ R₂ H₃) {L₁₂ : CategoryTheory.Functor C₁ C₃} {R₁₂ : CategoryTheory.Functor D₁ D₃} (eL : L₁.comp L₂ ≅ L₁₂) (eR : R₁.comp R₂ ≅ R₁₂) (X : C₁)
Goal: (w.vComp' w' eL eR).app X =
  CategoryTheory.CategoryStruct.comp (eR.inv.app (H₁.obj X))
    (CategoryTheory.CategoryStruct.comp (R₂.map (w.app X))
      (CategoryTheory.CategoryStruct.comp (w'.app (L₁.obj X)) (H₃.map (eL.hom.app X))))
-- CategoryTheory.TwoSquare.GuitartExact.vComp_iff_of_equivalences
lemma vComp_iff_of_equivalences (eL : C₂ ≌ C₃) (eR : D₂ ≌ D₃)
    (w' : H₂ ⋙ eR.functor ≅ eL.functor ⋙ H₃) :
    (w.vComp w'.hom).GuitartExact ↔ w.GuitartExact 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {D₁ : Type u_4} {D₂ : Type u_5} {D₃ : Type u_6} [CategoryTheory.Category.{u_11, u_1} C₁] [CategoryTheory.Category.{u_7, u_2} C₂] [CategoryTheory.Category.{u_8, u_3} C₃] [CategoryTheory.Category.{u_12, u_4} D₁] [CategoryTheory.Category.{u_9, u_5} D₂] [CategoryTheory.Category.{u_10, u_6} D₃] {H₁ : CategoryTheory.Functor C₁ D₁} {L₁ : CategoryTheory.Functor C₁ C₂} {R₁ : CategoryTheory.Functor D₁ D₂} {H₂ : CategoryTheory.Functor C₂ D₂} (w : CategoryTheory.TwoSquare H₁ L₁ R₁ H₂) {H₃ : CategoryTheory.Functor C₃ D₃} (eL : C₂ ≌ C₃) (eR : D₂ ≌ D₃) (w' : H₂.comp eR.functor ≅ eL.functor.comp H₃)
Goal: (w.vComp w'.hom).GuitartExact ↔ w.GuitartExact
-- CategoryTheory.TwoSquare.GuitartExact.vComp'_iff_of_equivalences
lemma vComp'_iff_of_equivalences (E : C₂ ≌ C₃) (E' : D₂ ≌ D₃)
    (w' : H₂ ⋙ E'.functor ≅ E.functor ⋙ H₃) {L₁₂ : C₁ ⥤ C₃}
    {R₁₂ : D₁ ⥤ D₃} (eL : L₁ ⋙ E.functor ≅ L₁₂)
    (eR : R₁ ⋙ E'.functor ≅ R₁₂) :
    (w.vComp' w'.hom eL eR).GuitartExact ↔ w.GuitartExact 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {D₁ : Type u_4} {D₂ : Type u_5} {D₃ : Type u_6} [CategoryTheory.Category.{u_11, u_1} C₁] [CategoryTheory.Category.{u_7, u_2} C₂] [CategoryTheory.Category.{u_8, u_3} C₃] [CategoryTheory.Category.{u_12, u_4} D₁] [CategoryTheory.Category.{u_9, u_5} D₂] [CategoryTheory.Category.{u_10, u_6} D₃] {H₁ : CategoryTheory.Functor C₁ D₁} {L₁ : CategoryTheory.Functor C₁ C₂} {R₁ : CategoryTheory.Functor D₁ D₂} {H₂ : CategoryTheory.Functor C₂ D₂} (w : CategoryTheory.TwoSquare H₁ L₁ R₁ H₂) {H₃ : CategoryTheory.Functor C₃ D₃} (E : C₂ ≌ C₃) (E' : D₂ ≌ D₃) (w' : H₂.comp E'.functor ≅ E.functor.comp H₃) {L₁₂ : CategoryTheory.Functor C₁ C₃} {R₁₂ : CategoryTheory.Functor D₁ D₃} (eL : L₁.comp E.functor ≅ L₁₂) (eR : R₁.comp E'.functor ≅ R₁₂)
Goal: (w.vComp' w'.hom eL eR).GuitartExact ↔ w.GuitartExact
-- CategoryTheory.Equivalence.coverPreserving
theorem coverPreserving : CoverPreserving J (e.inverse.inducedTopology J) e.functor 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: CategoryTheory.CoverPreserving J (e.inverse.inducedTopology J) e.functor
-- CategoryTheory.Equivalence.TransportsGrothendieckTopology.eq_inducedTopology
class TransportsGrothendieckTopology : Prop where
    eq_inducedTopology : K = e.inverse.inducedTopology J
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {K : CategoryTheory.GrothendieckTopology D} {e : C ≌ D} [self : CategoryTheory.Equivalence.TransportsGrothendieckTopology J K e]
Goal: K = e.inverse.inducedTopology J
-- CategoryTheory.Equivalence.eq_inducedTopology_of_transports
theorem eq_inducedTopology_of_transports : K = e.inverse.inducedTopology J 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (e : C ≌ D) [CategoryTheory.Equivalence.TransportsGrothendieckTopology J K e]
Goal: K = e.inverse.inducedTopology J
-- CategoryTheory.Equivalence.sheafCongr.functor_obj_val_map
@[simps!]
def sheafCongr.functor : Sheaf J A ⥤ Sheaf K A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (e : C ≌ D) (A : Type u₃) [CategoryTheory.Category.{v₃, u₃} A] [CategoryTheory.Equivalence.TransportsGrothendieckTopology J K e] (F : CategoryTheory.Sheaf J A)
Goal: ∀ {X Y : Dᵒᵖ} (f : X ⟶ Y),
  ((CategoryTheory.Equivalence.sheafCongr.functor J K e A).obj F).val.map f = F.val.map (e.inverse.map f.unop).op
-- CategoryTheory.Equivalence.sheafCongr.functor_obj_val_obj
@[simps!]
def sheafCongr.functor : Sheaf J A ⥤ Sheaf K A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (e : C ≌ D) (A : Type u₃) [CategoryTheory.Category.{v₃, u₃} A] [CategoryTheory.Equivalence.TransportsGrothendieckTopology J K e] (F : CategoryTheory.Sheaf J A) (X : Dᵒᵖ)
Goal: ((CategoryTheory.Equivalence.sheafCongr.functor J K e A).obj F).val.obj X =
  F.val.obj (Opposite.op (e.inverse.obj (Opposite.unop X)))
-- CategoryTheory.Equivalence.sheafCongr.functor_map_val_app
@[simps!]
def sheafCongr.functor : Sheaf J A ⥤ Sheaf K A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (e : C ≌ D) (A : Type u₃) [CategoryTheory.Category.{v₃, u₃} A] [CategoryTheory.Equivalence.TransportsGrothendieckTopology J K e]
Goal: ∀ {X Y : CategoryTheory.Sheaf J A} (f : X ⟶ Y) (X_1 : Dᵒᵖ),
  ((CategoryTheory.Equivalence.sheafCongr.functor J K e A).map f).val.app X_1 =
    f.val.app (Opposite.op (e.inverse.obj (Opposite.unop X_1)))
-- CategoryTheory.Equivalence.sheafCongr.inverse_obj_val_obj
@[simps!]
def sheafCongr.inverse : Sheaf K A ⥤ Sheaf J A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (e : C ≌ D) (A : Type u₃) [CategoryTheory.Category.{v₃, u₃} A] [CategoryTheory.Equivalence.TransportsGrothendieckTopology J K e] (F : CategoryTheory.Sheaf K A) (X : Cᵒᵖ)
Goal: ((CategoryTheory.Equivalence.sheafCongr.inverse J K e A).obj F).val.obj X =
  F.val.obj (Opposite.op (e.functor.obj (Opposite.unop X)))
-- CategoryTheory.Equivalence.sheafCongr.inverse_obj_val_map
@[simps!]
def sheafCongr.inverse : Sheaf K A ⥤ Sheaf J A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (e : C ≌ D) (A : Type u₃) [CategoryTheory.Category.{v₃, u₃} A] [CategoryTheory.Equivalence.TransportsGrothendieckTopology J K e] (F : CategoryTheory.Sheaf K A)
Goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y),
  ((CategoryTheory.Equivalence.sheafCongr.inverse J K e A).obj F).val.map f = F.val.map (e.functor.map f.unop).op
-- CategoryTheory.Equivalence.sheafCongr.inverse_map_val_app
@[simps!]
def sheafCongr.inverse : Sheaf K A ⥤ Sheaf J A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (e : C ≌ D) (A : Type u₃) [CategoryTheory.Category.{v₃, u₃} A] [CategoryTheory.Equivalence.TransportsGrothendieckTopology J K e]
Goal: ∀ {X Y : CategoryTheory.Sheaf K A} (f : X ⟶ Y) (X_1 : Cᵒᵖ),
  ((CategoryTheory.Equivalence.sheafCongr.inverse J K e A).map f).val.app X_1 =
    f.val.app (Opposite.op (e.functor.obj (Opposite.unop X_1)))
-- CategoryTheory.Equivalence.sheafCongr.unitIso_inv_app_val_app
@[simps!]
def sheafCongr.unitIso : 𝟭 (Sheaf J A) ≅ functor J K e A ⋙ inverse J K e A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (e : C ≌ D) (A : Type u₃) [CategoryTheory.Category.{v₃, u₃} A] [CategoryTheory.Equivalence.TransportsGrothendieckTopology J K e] (X : CategoryTheory.Sheaf J A)
Goal: ∀ (X_1 : Cᵒᵖ),
  ((CategoryTheory.Equivalence.sheafCongr.unitIso J K e A).inv.app X).val.app X_1 =
    X.val.map (e.unitIso.hom.app (Opposite.unop X_1)).op
-- CategoryTheory.Equivalence.sheafCongr.unitIso_hom_app_val_app
@[simps!]
def sheafCongr.unitIso : 𝟭 (Sheaf J A) ≅ functor J K e A ⋙ inverse J K e A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (e : C ≌ D) (A : Type u₃) [CategoryTheory.Category.{v₃, u₃} A] [CategoryTheory.Equivalence.TransportsGrothendieckTopology J K e] (X : CategoryTheory.Sheaf J A)
Goal: ∀ (X_1 : Cᵒᵖ),
  ((CategoryTheory.Equivalence.sheafCongr.unitIso J K e A).hom.app X).val.app X_1 =
    X.val.map (e.unitIso.inv.app (Opposite.unop X_1)).op
-- CategoryTheory.Equivalence.sheafCongr.counitIso_inv_app_val_app
@[simps!]
def sheafCongr.counitIso : inverse J K e A ⋙ functor J K e A ≅ 𝟭 (Sheaf _ A) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (e : C ≌ D) (A : Type u₃) [CategoryTheory.Category.{v₃, u₃} A] [CategoryTheory.Equivalence.TransportsGrothendieckTopology J K e] (X : CategoryTheory.Sheaf K A)
Goal: ∀ (X_1 : Dᵒᵖ),
  ((CategoryTheory.Equivalence.sheafCongr.counitIso J K e A).inv.app X).val.app X_1 =
    X.val.map (e.counitIso.hom.app (Opposite.unop X_1)).op
-- CategoryTheory.Equivalence.sheafCongr.counitIso_hom_app_val_app
@[simps!]
def sheafCongr.counitIso : inverse J K e A ⋙ functor J K e A ≅ 𝟭 (Sheaf _ A) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (e : C ≌ D) (A : Type u₃) [CategoryTheory.Category.{v₃, u₃} A] [CategoryTheory.Equivalence.TransportsGrothendieckTopology J K e] (X : CategoryTheory.Sheaf K A)
Goal: ∀ (X_1 : Dᵒᵖ),
  ((CategoryTheory.Equivalence.sheafCongr.counitIso J K e A).hom.app X).val.app X_1 =
    X.val.map (e.counitIso.inv.app (Opposite.unop X_1)).op
-- CategoryTheory.Equivalence.hasSheafify
theorem hasSheafify : HasSheafify J A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (e : C ≌ D) (A : Type u₃) [CategoryTheory.Category.{v₃, u₃} A] [CategoryTheory.Equivalence.TransportsGrothendieckTopology J K e] [CategoryTheory.HasSheafify K A]
Goal: CategoryTheory.HasSheafify J A
-- CategoryTheory.Equivalence.hasSheafCompose
theorem hasSheafCompose : J.HasSheafCompose F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (e : C ≌ D) [CategoryTheory.Equivalence.TransportsGrothendieckTopology J K e] {A : Type u_1} [CategoryTheory.Category.{u_3, u_1} A] {B : Type u_2} [CategoryTheory.Category.{u_4, u_2} B] (F : CategoryTheory.Functor A B) [K.HasSheafCompose F]
Goal: J.HasSheafCompose F
-- CategoryTheory.GrothendieckTopology.W_inverseImage_whiskeringLeft
lemma W_inverseImage_whiskeringLeft :
    K.W.inverseImage ((whiskeringLeft Dᵒᵖ Cᵒᵖ A).obj G.op) = J.W 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (G : CategoryTheory.Functor D C) {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] [G.IsCoverDense J] [G.IsContinuous K J] [G.Full] [(G.sheafPushforwardContinuous A K J).EssSurj]
Goal: K.W.inverseImage ((CategoryTheory.whiskeringLeft Dᵒᵖ Cᵒᵖ A).obj G.op) = J.W
-- CategoryTheory.GrothendieckTopology.W_whiskerLeft_iff
lemma W_whiskerLeft_iff {P Q : Cᵒᵖ ⥤ A} (f : P ⟶ Q) :
    K.W (whiskerLeft G.op f) ↔ J.W f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (G : CategoryTheory.Functor D C) {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] [G.IsCoverDense J] [G.IsContinuous K J] [G.Full] [(G.sheafPushforwardContinuous A K J).EssSurj] {P Q : CategoryTheory.Functor Cᵒᵖ A} (f : P ⟶ Q)
Goal: K.W (CategoryTheory.whiskerLeft G.op f) ↔ J.W f
-- CategoryTheory.GrothendieckTopology.WEqualsLocallyBijective.transport
lemma WEqualsLocallyBijective.transport : J.WEqualsLocallyBijective A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (G : CategoryTheory.Functor D C) {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] [G.IsCoverDense J] [G.IsContinuous K J] [G.Full] [(G.sheafPushforwardContinuous A K J).EssSurj] [G.IsCocontinuous K J] (hG : CategoryTheory.CoverPreserving K J G) [CategoryTheory.ConcreteCategory A] [K.WEqualsLocallyBijective A]
Goal: J.WEqualsLocallyBijective A
-- CategoryTheory.extensiveTopology.mem_sieves_iff_contains_colimit_cofan
lemma extensiveTopology.mem_sieves_iff_contains_colimit_cofan {X : C} (S : Sieve X) :
    S ∈ (extensiveTopology C).sieves X ↔
      (∃ (α : Type) (_ : Finite α) (Y : α → C) (π : (a : α) → (Y a ⟶ X)),
        Nonempty (IsColimit (Cofan.mk X π)) ∧ (∀ a : α, (S.arrows) (π a))) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.FinitaryPreExtensive C] {X : C} (S : CategoryTheory.Sieve X)
Goal: S ∈ (CategoryTheory.extensiveTopology C).sieves X ↔
  ∃ α,
    ∃ (_ : Finite α),
      ∃ Y π, Nonempty (CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Cofan.mk X π)) ∧ ∀ (a : α), S.arrows (π a)
-- CategoryTheory.Endofunctor.Algebra.Hom.h
@[ext]
structure Hom (A₀ A₁ : Algebra F) where
    f : A₀.1 ⟶ A₁.1
    h : F.map f ≫ A₁.str = A₀.str ≫ f := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C} {A₀ A₁ : CategoryTheory.Endofunctor.Algebra F} (self : A₀.Hom A₁)
Goal: CategoryTheory.CategoryStruct.comp (F.map self.f) A₁.str = CategoryTheory.CategoryStruct.comp A₀.str self.f
-- CategoryTheory.Endofunctor.Algebra.ext
@[ext]
lemma ext {A B : Algebra F} {f g : A ⟶ B} (w : f.f = g.f := by aesop_cat) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C} {A B : CategoryTheory.Endofunctor.Algebra F} {f g : A ⟶ B} (w : f.f = g.f := by aesop_cat)
Goal: f = g
-- CategoryTheory.Endofunctor.Algebra.id_eq_id
@[simp]
theorem id_eq_id : Algebra.Hom.id A = 𝟙 A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C} (A : CategoryTheory.Endofunctor.Algebra F)
Goal: CategoryTheory.Endofunctor.Algebra.Hom.id A = CategoryTheory.CategoryStruct.id A
-- CategoryTheory.Endofunctor.Algebra.id_f
@[simp]
theorem id_f : (𝟙 _ : A ⟶ A).1 = 𝟙 A.1 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C} (A : CategoryTheory.Endofunctor.Algebra F)
Goal: (CategoryTheory.CategoryStruct.id A).f = CategoryTheory.CategoryStruct.id A.a
-- CategoryTheory.Endofunctor.Algebra.comp_eq_comp
@[simp]
theorem comp_eq_comp : Algebra.Hom.comp f g = f ≫ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C} {A₀ A₁ A₂ : CategoryTheory.Endofunctor.Algebra F} (f : A₀ ⟶ A₁) (g : A₁ ⟶ A₂)
Goal: CategoryTheory.Endofunctor.Algebra.Hom.comp f g = CategoryTheory.CategoryStruct.comp f g