ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.NatTrans.removeLeftOp_app
@[simps]
protected def removeLeftOp (α : F.leftOp ⟶ G.leftOp) : G ⟶ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C Dᵒᵖ} (α : F.leftOp ⟶ G.leftOp) (X : C)
Goal: (CategoryTheory.NatTrans.removeLeftOp α).app X = (α.app (Opposite.op X)).op
-- CategoryTheory.NatTrans.removeLeftOp_id
@[simp]
theorem removeLeftOp_id : NatTrans.removeLeftOp (𝟙 F.leftOp) = 𝟙 F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C Dᵒᵖ}
Goal: CategoryTheory.NatTrans.removeLeftOp (CategoryTheory.CategoryStruct.id F.leftOp) = CategoryTheory.CategoryStruct.id F
-- CategoryTheory.NatTrans.rightOp_app
@[simps]
protected def rightOp (α : F ⟶ G) : G.rightOp ⟶ F.rightOp 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor Cᵒᵖ D} (α : F ⟶ G) (X : C)
Goal: (CategoryTheory.NatTrans.rightOp α).app X = (α.app (Opposite.op X)).op
-- CategoryTheory.NatTrans.rightOp_id
@[simp]
theorem rightOp_id : NatTrans.rightOp (𝟙 F : F ⟶ F) = 𝟙 F.rightOp 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor Cᵒᵖ D}
Goal: CategoryTheory.NatTrans.rightOp (CategoryTheory.CategoryStruct.id F) = CategoryTheory.CategoryStruct.id F.rightOp
-- CategoryTheory.NatTrans.rightOp_comp
@[simp]
theorem rightOp_comp (α : F ⟶ G) (β : G ⟶ H) : NatTrans.rightOp (α ≫ β) =
    NatTrans.rightOp β ≫ NatTrans.rightOp α 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G H : CategoryTheory.Functor Cᵒᵖ D} (α : F ⟶ G) (β : G ⟶ H)
Goal: CategoryTheory.NatTrans.rightOp (CategoryTheory.CategoryStruct.comp α β) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTrans.rightOp β) (CategoryTheory.NatTrans.rightOp α)
-- CategoryTheory.NatTrans.removeRightOp_app
@[simps]
protected def removeRightOp (α : F.rightOp ⟶ G.rightOp) : G ⟶ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor Cᵒᵖ D} (α : F.rightOp ⟶ G.rightOp) (X : Cᵒᵖ)
Goal: (CategoryTheory.NatTrans.removeRightOp α).app X = (α.app (Opposite.unop X)).unop
-- CategoryTheory.NatTrans.removeRightOp_id
@[simp]
theorem removeRightOp_id : NatTrans.removeRightOp (𝟙 F.rightOp) = 𝟙 F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor Cᵒᵖ D}
Goal: CategoryTheory.NatTrans.removeRightOp (CategoryTheory.CategoryStruct.id F.rightOp) = CategoryTheory.CategoryStruct.id F
-- CategoryTheory.Iso.op_inv
@[simps]
protected def op (α : X ≅ Y) : op Y ≅ op X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (α : X ≅ Y)
Goal: α.op.inv = α.inv.op
-- CategoryTheory.Iso.op_hom
@[simps]
protected def op (α : X ≅ Y) : op Y ≅ op X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (α : X ≅ Y)
Goal: α.op.hom = α.hom.op
-- CategoryTheory.Iso.unop_hom
@[simps]
def unop {X Y : Cᵒᵖ} (f : X ≅ Y) : Y.unop ≅ X.unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : X ≅ Y)
Goal: f.unop.hom = f.hom.unop
-- CategoryTheory.Iso.unop_inv
@[simps]
def unop {X Y : Cᵒᵖ} (f : X ≅ Y) : Y.unop ≅ X.unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : X ≅ Y)
Goal: f.unop.inv = f.inv.unop
-- CategoryTheory.Iso.unop_op
@[simp]
theorem unop_op {X Y : Cᵒᵖ} (f : X ≅ Y) : f.unop.op = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : X ≅ Y)
Goal: f.unop.op = f
-- CategoryTheory.Iso.op_unop
@[simp]
theorem op_unop {X Y : C} (f : X ≅ Y) : f.op.unop = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ≅ Y)
Goal: f.op.unop = f
-- CategoryTheory.Iso.unop_hom_inv_id_app
@[reassoc (attr := simp)]
lemma unop_hom_inv_id_app : (e.hom.app X).unop ≫ (e.inv.app X).unop = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {F G : CategoryTheory.Functor C Dᵒᵖ} (e : F ≅ G) (X : C)
Goal: CategoryTheory.CategoryStruct.comp (e.hom.app X).unop (e.inv.app X).unop =
  CategoryTheory.CategoryStruct.id (Opposite.unop (G.obj X))
-- CategoryTheory.Iso.unop_inv_hom_id_app
@[reassoc (attr := simp)]
lemma unop_inv_hom_id_app : (e.inv.app X).unop ≫ (e.hom.app X).unop = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {F G : CategoryTheory.Functor C Dᵒᵖ} (e : F ≅ G) (X : C)
Goal: CategoryTheory.CategoryStruct.comp (e.inv.app X).unop (e.hom.app X).unop =
  CategoryTheory.CategoryStruct.id (Opposite.unop (F.obj X))
-- CategoryTheory.NatIso.op_inv
@[simps]
protected def op (α : F ≅ G) : G.op ≅ F.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} (α : F ≅ G)
Goal: (CategoryTheory.NatIso.op α).inv = CategoryTheory.NatTrans.op α.inv
-- CategoryTheory.NatIso.op_hom
@[simps]
protected def op (α : F ≅ G) : G.op ≅ F.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} (α : F ≅ G)
Goal: (CategoryTheory.NatIso.op α).hom = CategoryTheory.NatTrans.op α.hom
-- CategoryTheory.NatIso.removeOp_inv
@[simps]
protected def removeOp (α : F.op ≅ G.op) : G ≅ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} (α : F.op ≅ G.op)
Goal: (CategoryTheory.NatIso.removeOp α).inv = CategoryTheory.NatTrans.removeOp α.inv
-- CategoryTheory.NatIso.removeOp_hom
@[simps]
protected def removeOp (α : F.op ≅ G.op) : G ≅ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} (α : F.op ≅ G.op)
Goal: (CategoryTheory.NatIso.removeOp α).hom = CategoryTheory.NatTrans.removeOp α.hom
-- CategoryTheory.NatIso.unop_inv
@[simps]
protected def unop {F G : Cᵒᵖ ⥤ Dᵒᵖ} (α : F ≅ G) : G.unop ≅ F.unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ} (α : F ≅ G)
Goal: (CategoryTheory.NatIso.unop α).inv = CategoryTheory.NatTrans.unop α.inv
-- CategoryTheory.NatIso.unop_hom
@[simps]
protected def unop {F G : Cᵒᵖ ⥤ Dᵒᵖ} (α : F ≅ G) : G.unop ≅ F.unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ} (α : F ≅ G)
Goal: (CategoryTheory.NatIso.unop α).hom = CategoryTheory.NatTrans.unop α.hom
-- CategoryTheory.Equivalence.op_unitIso
@[simps]
def op (e : C ≌ D) : Cᵒᵖ ≌ Dᵒᵖ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: e.op.unitIso = (CategoryTheory.NatIso.op e.unitIso).symm
-- CategoryTheory.Equivalence.op_functor
@[simps]
def op (e : C ≌ D) : Cᵒᵖ ≌ Dᵒᵖ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: e.op.functor = e.functor.op
-- CategoryTheory.Equivalence.op_inverse
@[simps]
def op (e : C ≌ D) : Cᵒᵖ ≌ Dᵒᵖ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: e.op.inverse = e.inverse.op
-- CategoryTheory.Equivalence.op_counitIso
@[simps]
def op (e : C ≌ D) : Cᵒᵖ ≌ Dᵒᵖ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: e.op.counitIso = (CategoryTheory.NatIso.op e.counitIso).symm
-- CategoryTheory.Equivalence.unop_functor
@[simps]
def unop (e : Cᵒᵖ ≌ Dᵒᵖ) : C ≌ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : Cᵒᵖ ≌ Dᵒᵖ)
Goal: e.unop.functor = e.functor.unop
-- CategoryTheory.Equivalence.unop_unitIso
@[simps]
def unop (e : Cᵒᵖ ≌ Dᵒᵖ) : C ≌ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : Cᵒᵖ ≌ Dᵒᵖ)
Goal: e.unop.unitIso = (CategoryTheory.NatIso.unop e.unitIso).symm
-- CategoryTheory.Equivalence.unop_counitIso
@[simps]
def unop (e : Cᵒᵖ ≌ Dᵒᵖ) : C ≌ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : Cᵒᵖ ≌ Dᵒᵖ)
Goal: e.unop.counitIso = (CategoryTheory.NatIso.unop e.counitIso).symm
-- CategoryTheory.Equivalence.unop_inverse
@[simps]
def unop (e : Cᵒᵖ ≌ Dᵒᵖ) : C ≌ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : Cᵒᵖ ≌ Dᵒᵖ)
Goal: e.unop.inverse = e.inverse.unop
-- CategoryTheory.opEquiv_apply
@[simps]
def opEquiv (A B : Cᵒᵖ) : (A ⟶ B) ≃ (B.unop ⟶ A.unop) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (A B : Cᵒᵖ) (f : A ⟶ B)
Goal: (CategoryTheory.opEquiv A B) f = f.unop
-- CategoryTheory.opEquiv_symm_apply
@[simps]
def opEquiv (A B : Cᵒᵖ) : (A ⟶ B) ≃ (B.unop ⟶ A.unop) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (A B : Cᵒᵖ) (g : Opposite.unop B ⟶ Opposite.unop A)
Goal: (CategoryTheory.opEquiv A B).symm g = g.op
-- CategoryTheory.isoOpEquiv_symm_apply
@[simps]
def isoOpEquiv (A B : Cᵒᵖ) : (A ≅ B) ≃ (B.unop ≅ A.unop) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (A B : Cᵒᵖ) (g : Opposite.unop B ≅ Opposite.unop A)
Goal: (CategoryTheory.isoOpEquiv A B).symm g = g.op
-- CategoryTheory.isoOpEquiv_apply
@[simps]
def isoOpEquiv (A B : Cᵒᵖ) : (A ≅ B) ≃ (B.unop ≅ A.unop) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (A B : Cᵒᵖ) (f : A ≅ B)
Goal: (CategoryTheory.isoOpEquiv A B) f = f.unop
-- CategoryTheory.Functor.opUnopEquiv_unitIso
@[simps]
def opUnopEquiv : (C ⥤ D)ᵒᵖ ≌ Cᵒᵖ ⥤ Dᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D]
Goal: (CategoryTheory.Functor.opUnopEquiv C D).unitIso =
  CategoryTheory.NatIso.ofComponents (fun F => (Opposite.unop F).opUnopIso.op) ⋯
-- CategoryTheory.Functor.opUnopEquiv_inverse
@[simps]
def opUnopEquiv : (C ⥤ D)ᵒᵖ ≌ Cᵒᵖ ⥤ Dᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D]
Goal: (CategoryTheory.Functor.opUnopEquiv C D).inverse = CategoryTheory.Functor.opInv C D
-- CategoryTheory.Functor.opUnopEquiv_counitIso
@[simps]
def opUnopEquiv : (C ⥤ D)ᵒᵖ ≌ Cᵒᵖ ⥤ Dᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D]
Goal: (CategoryTheory.Functor.opUnopEquiv C D).counitIso = CategoryTheory.NatIso.ofComponents (fun F => F.unopOpIso) ⋯
-- CategoryTheory.Functor.opUnopEquiv_functor
@[simps]
def opUnopEquiv : (C ⥤ D)ᵒᵖ ≌ Cᵒᵖ ⥤ Dᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D]
Goal: (CategoryTheory.Functor.opUnopEquiv C D).functor = CategoryTheory.Functor.opHom C D
-- CategoryTheory.Functor.leftOpRightOpEquiv_inverse_map
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D]
Goal: ∀ {X Y : CategoryTheory.Functor C Dᵒᵖ} (η : X ⟶ Y),
  (CategoryTheory.Functor.leftOpRightOpEquiv C D).inverse.map η = (CategoryTheory.NatTrans.leftOp η).op
-- CategoryTheory.Functor.leftOpRightOpEquiv_unitIso_inv_app
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : (CategoryTheory.Functor Cᵒᵖ D)ᵒᵖ)
Goal: (CategoryTheory.Functor.leftOpRightOpEquiv C D).unitIso.inv.app X = (Opposite.unop X).rightOpLeftOpIso.inv.op
-- CategoryTheory.Functor.leftOpRightOpEquiv_counitIso_hom_app_app
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : CategoryTheory.Functor C Dᵒᵖ)
Goal: ∀ (X_1 : C),
  ((CategoryTheory.Functor.leftOpRightOpEquiv C D).counitIso.hom.app X).app X_1 =
    CategoryTheory.CategoryStruct.id (X.obj X_1)
-- CategoryTheory.Functor.leftOpRightOpEquiv_inverse_obj
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C Dᵒᵖ)
Goal: (CategoryTheory.Functor.leftOpRightOpEquiv C D).inverse.obj F = Opposite.op F.leftOp
-- CategoryTheory.Functor.leftOpRightOpEquiv_counitIso_inv_app_app
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : CategoryTheory.Functor C Dᵒᵖ)
Goal: ∀ (X_1 : C),
  ((CategoryTheory.Functor.leftOpRightOpEquiv C D).counitIso.inv.app X).app X_1 =
    CategoryTheory.CategoryStruct.id (X.obj X_1)
-- CategoryTheory.Functor.leftOpRightOpEquiv_functor_obj_obj
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (F : (CategoryTheory.Functor Cᵒᵖ D)ᵒᵖ) (X : C)
Goal: ((CategoryTheory.Functor.leftOpRightOpEquiv C D).functor.obj F).obj X =
  Opposite.op ((Opposite.unop F).obj (Opposite.op X))
-- CategoryTheory.Functor.leftOpRightOpEquiv_functor_obj_map
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (F : (CategoryTheory.Functor Cᵒᵖ D)ᵒᵖ)
Goal: ∀ {X Y : C} (f : X ⟶ Y),
  ((CategoryTheory.Functor.leftOpRightOpEquiv C D).functor.obj F).map f = ((Opposite.unop F).map f.op).op
-- CategoryTheory.Functor.leftOpRightOpEquiv_functor_map_app
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D]
Goal: ∀ {X Y : (CategoryTheory.Functor Cᵒᵖ D)ᵒᵖ} (η : X ⟶ Y) (X_1 : C),
  ((CategoryTheory.Functor.leftOpRightOpEquiv C D).functor.map η).app X_1 = (η.unop.app (Opposite.op X_1)).op
-- CategoryTheory.Functor.leftOpRightOpEquiv_unitIso_hom_app
@[simps!]
def leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : (CategoryTheory.Functor Cᵒᵖ D)ᵒᵖ)
Goal: (CategoryTheory.Functor.leftOpRightOpEquiv C D).unitIso.hom.app X = (Opposite.unop X).rightOpLeftOpIso.hom.op
-- CategoryTheory.isSheaf_coherent
lemma isSheaf_coherent (P : Cᵒᵖ ⥤ Type w) :
    Presieve.IsSheaf (coherentTopology C) P ↔
    (∀ (B : C) (α : Type) [Finite α] (X : α → C) (π : (a : α) → (X a ⟶ B)),
      EffectiveEpiFamily X π → (Presieve.ofArrows X π).IsSheafFor P) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Precoherent C] (P : CategoryTheory.Functor Cᵒᵖ (Type w))
Goal: CategoryTheory.Presieve.IsSheaf (CategoryTheory.coherentTopology C) P ↔
  ∀ (B : C) (α : Type) [inst : Finite α] (X : α → C) (π : (a : α) → X a ⟶ B),
    CategoryTheory.EffectiveEpiFamily X π → CategoryTheory.Presieve.IsSheafFor P (CategoryTheory.Presieve.ofArrows X π)
-- CategoryTheory.coherentTopology.isSheaf_yoneda_obj
theorem isSheaf_yoneda_obj (W : C) : Presieve.IsSheaf (coherentTopology C) (yoneda.obj W) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Precoherent C] (W : C)
Goal: CategoryTheory.Presieve.IsSheaf (CategoryTheory.coherentTopology C) (CategoryTheory.yoneda.obj W)
-- CategoryTheory.coherentTopology.subcanonical
theorem subcanonical : Sheaf.Subcanonical (coherentTopology C) 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Precoherent C]
Goal: CategoryTheory.Sheaf.Subcanonical (CategoryTheory.coherentTopology C)
-- CategoryTheory.IsPushout.IsVanKampen.flip
theorem IsPushout.IsVanKampen.flip {H : IsPushout f g h i} (H' : H.IsVanKampen) :
    H.flip.IsVanKampen 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} {H : CategoryTheory.IsPushout f g h i} (H' : H.IsVanKampen)
Goal: ⋯.IsVanKampen
-- CategoryTheory.IsPushout.isVanKampen_iff
theorem IsPushout.isVanKampen_iff (H : IsPushout f g h i) :
    H.IsVanKampen ↔ IsVanKampenColimit (PushoutCocone.mk h i H.w) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} (H : CategoryTheory.IsPushout f g h i)
Goal: H.IsVanKampen ↔ CategoryTheory.IsVanKampenColimit (CategoryTheory.Limits.PushoutCocone.mk h i ⋯)
-- CategoryTheory.is_coprod_iff_isPushout
theorem is_coprod_iff_isPushout {X E Y YE : C} (c : BinaryCofan X E) (hc : IsColimit c) {f : X ⟶ Y}
    {iY : Y ⟶ YE} {fE : c.pt ⟶ YE} (H : CommSq f c.inl iY fE) :
    Nonempty (IsColimit (BinaryCofan.mk (c.inr ≫ fE) iY)) ↔ IsPushout f c.inl iY fE 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X E Y YE : C} (c : CategoryTheory.Limits.BinaryCofan X E) (hc : CategoryTheory.Limits.IsColimit c) {f : X ⟶ Y} {iY : Y ⟶ YE} {fE : c.pt ⟶ YE} (H : CategoryTheory.CommSq f c.inl iY fE)
Goal: Nonempty
    (CategoryTheory.Limits.IsColimit
      (CategoryTheory.Limits.BinaryCofan.mk (CategoryTheory.CategoryStruct.comp c.inr fE) iY)) ↔
  CategoryTheory.IsPushout f c.inl iY fE
-- CategoryTheory.IsPushout.isVanKampen_inl
theorem IsPushout.isVanKampen_inl {W E X Z : C} (c : BinaryCofan W E) [FinitaryExtensive C]
    [HasPullbacks C] (hc : IsColimit c) (f : W ⟶ X) (h : X ⟶ Z) (i : c.pt ⟶ Z)
    (H : IsPushout f c.inl h i) : H.IsVanKampen 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W E X Z : C} (c : CategoryTheory.Limits.BinaryCofan W E) [CategoryTheory.FinitaryExtensive C] [CategoryTheory.Limits.HasPullbacks C] (hc : CategoryTheory.Limits.IsColimit c) (f : W ⟶ X) (h : X ⟶ Z) (i : c.pt ⟶ Z) (H : CategoryTheory.IsPushout f c.inl h i)
Goal: H.IsVanKampen
-- CategoryTheory.IsPushout.IsVanKampen.isPullback_of_mono_left
theorem IsPushout.IsVanKampen.isPullback_of_mono_left [Mono f] {H : IsPushout f g h i}
    (H' : H.IsVanKampen) : IsPullback f g h i 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} [CategoryTheory.Mono f] {H : CategoryTheory.IsPushout f g h i} (H' : H.IsVanKampen)
Goal: CategoryTheory.IsPullback f g h i
-- CategoryTheory.IsPushout.IsVanKampen.isPullback_of_mono_right
theorem IsPushout.IsVanKampen.isPullback_of_mono_right [Mono g] {H : IsPushout f g h i}
    (H' : H.IsVanKampen) : IsPullback f g h i 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} [CategoryTheory.Mono g] {H : CategoryTheory.IsPushout f g h i} (H' : H.IsVanKampen)
Goal: CategoryTheory.IsPullback f g h i
-- CategoryTheory.IsPushout.IsVanKampen.mono_of_mono_left
theorem IsPushout.IsVanKampen.mono_of_mono_left [Mono f] {H : IsPushout f g h i}
    (H' : H.IsVanKampen) : Mono i 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} [CategoryTheory.Mono f] {H : CategoryTheory.IsPushout f g h i} (H' : H.IsVanKampen)
Goal: CategoryTheory.Mono i
-- CategoryTheory.IsPushout.IsVanKampen.mono_of_mono_right
theorem IsPushout.IsVanKampen.mono_of_mono_right [Mono g] {H : IsPushout f g h i}
    (H' : H.IsVanKampen) : Mono h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} [CategoryTheory.Mono g] {H : CategoryTheory.IsPushout f g h i} (H' : H.IsVanKampen)
Goal: CategoryTheory.Mono h
-- CategoryTheory.Adhesive.hasPushout_of_mono_left
class Adhesive (C : Type u) [Category.{v} C] : Prop where
  [hasPullback_of_mono_left : ∀ {X Y S : C} (f : X ⟶ S) (g : Y ⟶ S) [Mono f], HasPullback f g]
  [hasPushout_of_mono_left : ∀ {X Y S : C} (f : S ⟶ X) (g : S ⟶ Y) [Mono f], HasPushout f g]
  van_kampen : ∀ {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} [Mono f]
    (H : IsPushout f g h i), H.IsVanKampen
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Adhesive C] {X Y S : C} (f : S ⟶ X) (g : S ⟶ Y) [CategoryTheory.Mono f]
Goal: CategoryTheory.Limits.HasPushout f g
-- CategoryTheory.Adhesive.hasPullback_of_mono_left
class Adhesive (C : Type u) [Category.{v} C] : Prop where
  [hasPullback_of_mono_left : ∀ {X Y S : C} (f : X ⟶ S) (g : Y ⟶ S) [Mono f], HasPullback f g]
  [hasPushout_of_mono_left : ∀ {X Y S : C} (f : S ⟶ X) (g : S ⟶ Y) [Mono f], HasPushout f g]
  van_kampen : ∀ {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} [Mono f]
    (H : IsPushout f g h i), H.IsVanKampen
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Adhesive C] {X Y S : C} (f : X ⟶ S) (g : Y ⟶ S) [CategoryTheory.Mono f]
Goal: CategoryTheory.Limits.HasPullback f g
-- CategoryTheory.Adhesive.van_kampen
class Adhesive (C : Type u) [Category.{v} C] : Prop where
  [hasPullback_of_mono_left : ∀ {X Y S : C} (f : X ⟶ S) (g : Y ⟶ S) [Mono f], HasPullback f g]
  [hasPushout_of_mono_left : ∀ {X Y S : C} (f : S ⟶ X) (g : S ⟶ Y) [Mono f], HasPushout f g]
  van_kampen : ∀ {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} [Mono f]
    (H : IsPushout f g h i), H.IsVanKampen
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Adhesive C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} [CategoryTheory.Mono f] (H : CategoryTheory.IsPushout f g h i)
Goal: H.IsVanKampen
-- CategoryTheory.Adhesive.van_kampen'
theorem Adhesive.van_kampen' [Adhesive C] [Mono g] (H : IsPushout f g h i) : H.IsVanKampen 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} [CategoryTheory.Adhesive C] [CategoryTheory.Mono g] (H : CategoryTheory.IsPushout f g h i)
Goal: H.IsVanKampen
-- CategoryTheory.Adhesive.isPullback_of_isPushout_of_mono_left
theorem Adhesive.isPullback_of_isPushout_of_mono_left [Adhesive C] (H : IsPushout f g h i)
    [Mono f] : IsPullback f g h i 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} [CategoryTheory.Adhesive C] (H : CategoryTheory.IsPushout f g h i) [CategoryTheory.Mono f]
Goal: CategoryTheory.IsPullback f g h i
-- CategoryTheory.Adhesive.isPullback_of_isPushout_of_mono_right
theorem Adhesive.isPullback_of_isPushout_of_mono_right [Adhesive C] (H : IsPushout f g h i)
    [Mono g] : IsPullback f g h i 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} [CategoryTheory.Adhesive C] (H : CategoryTheory.IsPushout f g h i) [CategoryTheory.Mono g]
Goal: CategoryTheory.IsPullback f g h i
-- CategoryTheory.Adhesive.mono_of_isPushout_of_mono_left
theorem Adhesive.mono_of_isPushout_of_mono_left [Adhesive C] (H : IsPushout f g h i) [Mono f] :
    Mono i 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} [CategoryTheory.Adhesive C] (H : CategoryTheory.IsPushout f g h i) [CategoryTheory.Mono f]
Goal: CategoryTheory.Mono i
-- CategoryTheory.Adhesive.mono_of_isPushout_of_mono_right
theorem Adhesive.mono_of_isPushout_of_mono_right [Adhesive C] (H : IsPushout f g h i) [Mono g] :
    Mono h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} [CategoryTheory.Adhesive C] (H : CategoryTheory.IsPushout f g h i) [CategoryTheory.Mono g]
Goal: CategoryTheory.Mono h