ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.OverPresheafAux.counitBackward_counitForward
lemma counitBackward_counitForward (F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v)
    (s : CostructuredArrow yoneda A) : counitBackward F s ∘ counitForward F s = id 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} (F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)) (s : CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)
Goal: CategoryTheory.OverPresheafAux.counitBackward F s ∘ CategoryTheory.OverPresheafAux.counitForward F s = id
-- CategoryTheory.OverPresheafAux.counitAuxAux_hom
@[simps]
def counitAuxAux (F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v) (s : CostructuredArrow yoneda A) :
    F.obj (op s) ≅ OverArrows (yonedaCollectionPresheafToA F) s.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} (F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)) (s : CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)
Goal: ∀ (a : F.obj (Opposite.op s)),
  (CategoryTheory.OverPresheafAux.counitAuxAux F s).hom a = CategoryTheory.OverPresheafAux.counitForward F s a
-- CategoryTheory.OverPresheafAux.counitAuxAux_inv
@[simps]
def counitAuxAux (F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v) (s : CostructuredArrow yoneda A) :
    F.obj (op s) ≅ OverArrows (yonedaCollectionPresheafToA F) s.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} (F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)) (s : CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)
Goal: ∀ (a : CategoryTheory.OverPresheafAux.OverArrows (CategoryTheory.OverPresheafAux.yonedaCollectionPresheafToA F) s.hom),
  (CategoryTheory.OverPresheafAux.counitAuxAux F s).inv a = CategoryTheory.OverPresheafAux.counitBackward F s a
-- CategoryTheory.OverPresheafAux.counitAux_hom
@[simps! hom]
def counitAux (F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v) :
    F ≅ restrictedYonedaObj (yonedaCollectionPresheafToA F) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} (F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v))
Goal: (CategoryTheory.OverPresheafAux.counitAux F).hom =
  { app := fun X => (CategoryTheory.OverPresheafAux.counitAuxAux F (Opposite.unop X)).hom, naturality := ⋯ }
-- CategoryTheory.CommSq.right_adjoint
theorem right_adjoint (sq : CommSq u (G.map i) p v) (adj : G ⊣ F) :
    CommSq (adj.homEquiv _ _ u) i (F.map p) (adj.homEquiv _ _ v) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] {G : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D C} {A B : C} {X Y : D} {i : A ⟶ B} {p : X ⟶ Y} {u : G.obj A ⟶ X} {v : G.obj B ⟶ Y} (sq : CategoryTheory.CommSq u (G.map i) p v) (adj : G ⊣ F)
Goal: CategoryTheory.CommSq ((adj.homEquiv A X) u) i (F.map p) ((adj.homEquiv B Y) v)
-- CategoryTheory.CommSq.right_adjoint_hasLift_iff
theorem right_adjoint_hasLift_iff : HasLift (sq.right_adjoint adj) ↔ HasLift sq 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] {G : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D C} {A B : C} {X Y : D} {i : A ⟶ B} {p : X ⟶ Y} {u : G.obj A ⟶ X} {v : G.obj B ⟶ Y} (sq : CategoryTheory.CommSq u (G.map i) p v) (adj : G ⊣ F)
Goal: ⋯.HasLift ↔ sq.HasLift
-- CategoryTheory.CommSq.left_adjoint
theorem left_adjoint (sq : CommSq u i (F.map p) v) (adj : G ⊣ F) :
    CommSq ((adj.homEquiv _ _).symm u) (G.map i) p ((adj.homEquiv _ _).symm v) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] {G : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D C} {A B : C} {X Y : D} {i : A ⟶ B} {p : X ⟶ Y} {u : A ⟶ F.obj X} {v : B ⟶ F.obj Y} (sq : CategoryTheory.CommSq u i (F.map p) v) (adj : G ⊣ F)
Goal: CategoryTheory.CommSq ((adj.homEquiv A X).symm u) (G.map i) p ((adj.homEquiv B Y).symm v)
-- CategoryTheory.CommSq.left_adjoint_hasLift_iff
theorem left_adjoint_hasLift_iff : HasLift (sq.left_adjoint adj) ↔ HasLift sq 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] {G : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D C} {A B : C} {X Y : D} {i : A ⟶ B} {p : X ⟶ Y} {u : A ⟶ F.obj X} {v : B ⟶ F.obj Y} (sq : CategoryTheory.CommSq u i (F.map p) v) (adj : G ⊣ F)
Goal: ⋯.HasLift ↔ sq.HasLift
-- CategoryTheory.Adjunction.hasLiftingProperty_iff
theorem hasLiftingProperty_iff (adj : G ⊣ F) {A B : C} {X Y : D} (i : A ⟶ B) (p : X ⟶ Y) :
    HasLiftingProperty (G.map i) p ↔ HasLiftingProperty i (F.map p) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] {G : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D C} (adj : G ⊣ F) {A B : C} {X Y : D} (i : A ⟶ B) (p : X ⟶ Y)
Goal: CategoryTheory.HasLiftingProperty (G.map i) p ↔ CategoryTheory.HasLiftingProperty i (F.map p)
-- CategoryTheory.prod_comp_fst
@[simps (config := { notRecursive := [] }) Hom id_fst id_snd comp_fst comp_snd]
instance prod : Category.{max v₁ v₂} (C × D) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D]
Goal: ∀ {X Y Z : C × D} (f : X ⟶ Y) (g : Y ⟶ Z),
  (CategoryTheory.CategoryStruct.comp f g).1 = CategoryTheory.CategoryStruct.comp f.1 g.1
-- CategoryTheory.prod_id_snd
@[simps (config := { notRecursive := [] }) Hom id_fst id_snd comp_fst comp_snd]
instance prod : Category.{max v₁ v₂} (C × D) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : C × D)
Goal: (CategoryTheory.CategoryStruct.id X).2 = CategoryTheory.CategoryStruct.id X.2
-- CategoryTheory.prod_Hom
@[simps (config := { notRecursive := [] }) Hom id_fst id_snd comp_fst comp_snd]
instance prod : Category.{max v₁ v₂} (C × D) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X Y : C × D)
Goal: (X ⟶ Y) = ((X.1 ⟶ Y.1) × (X.2 ⟶ Y.2))
-- CategoryTheory.prod_comp_snd
@[simps (config := { notRecursive := [] }) Hom id_fst id_snd comp_fst comp_snd]
instance prod : Category.{max v₁ v₂} (C × D) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D]
Goal: ∀ {X Y Z : C × D} (f : X ⟶ Y) (g : Y ⟶ Z),
  (CategoryTheory.CategoryStruct.comp f g).2 = CategoryTheory.CategoryStruct.comp f.2 g.2
-- CategoryTheory.prod_id_fst
@[simps (config := { notRecursive := [] }) Hom id_fst id_snd comp_fst comp_snd]
instance prod : Category.{max v₁ v₂} (C × D) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : C × D)
Goal: (CategoryTheory.CategoryStruct.id X).1 = CategoryTheory.CategoryStruct.id X.1
-- CategoryTheory.prod_id
@[simp]
theorem prod_id (X : C) (Y : D) : 𝟙 (X, Y) = (𝟙 X, 𝟙 Y) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : C) (Y : D)
Goal: CategoryTheory.CategoryStruct.id (X, Y) = (CategoryTheory.CategoryStruct.id X, CategoryTheory.CategoryStruct.id Y)
-- CategoryTheory.prod_comp
@[simp]
theorem prod_comp {P Q R : C} {S T U : D} (f : (P, S) ⟶ (Q, T)) (g : (Q, T) ⟶ (R, U)) :
    f ≫ g = (f.1 ≫ g.1, f.2 ≫ g.2) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] {P Q R : C} {S T U : D} (f : (P, S) ⟶ (Q, T)) (g : (Q, T) ⟶ (R, U))
Goal: CategoryTheory.CategoryStruct.comp f g =
  (CategoryTheory.CategoryStruct.comp f.1 g.1, CategoryTheory.CategoryStruct.comp f.2 g.2)
-- CategoryTheory.isIso_prod_iff
theorem isIso_prod_iff {P Q : C} {S T : D} {f : (P, S) ⟶ (Q, T)} :
    IsIso f ↔ IsIso f.1 ∧ IsIso f.2 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] {P Q : C} {S T : D} {f : (P, S) ⟶ (Q, T)}
Goal: CategoryTheory.IsIso f ↔ CategoryTheory.IsIso f.1 ∧ CategoryTheory.IsIso f.2
-- CategoryTheory.prod.etaIso_hom
@[simps]
def prod.etaIso (X : C × D) : (X.1, X.2) ≅ X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : C × D)
Goal: (CategoryTheory.prod.etaIso X).hom =
  (CategoryTheory.CategoryStruct.id (X.1, X.2).1, CategoryTheory.CategoryStruct.id (X.1, X.2).2)
-- CategoryTheory.prod.etaIso_inv
@[simps]
def prod.etaIso (X : C × D) : (X.1, X.2) ≅ X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : C × D)
Goal: (CategoryTheory.prod.etaIso X).inv = (CategoryTheory.CategoryStruct.id X.1, CategoryTheory.CategoryStruct.id X.2)
-- CategoryTheory.Iso.prod_hom
@[simps]
def Iso.prod {P Q : C} {S T : D} (f : P ≅ Q) (g : S ≅ T) : (P, S) ≅ (Q, T) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {P Q : C} {S T : D} (f : P ≅ Q) (g : S ≅ T)
Goal: (f.prod g).hom = (f.hom, g.hom)
-- CategoryTheory.Iso.prod_inv
@[simps]
def Iso.prod {P Q : C} {S T : D} (f : P ≅ Q) (g : S ≅ T) : (P, S) ≅ (Q, T) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {P Q : C} {S T : D} (f : P ≅ Q) (g : S ≅ T)
Goal: (f.prod g).inv = (f.inv, g.inv)
-- CategoryTheory.Prod.sectl_map
@[simps]
def sectl (C : Type u₁) [Category.{v₁} C] {D : Type u₂} [Category.{v₂} D] (Z : D) : C ⥤ C × D 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (Z : D)
Goal: ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.Prod.sectl C Z).map f = (f, CategoryTheory.CategoryStruct.id Z)
-- CategoryTheory.Prod.sectl_obj
@[simps]
def sectl (C : Type u₁) [Category.{v₁} C] {D : Type u₂} [Category.{v₂} D] (Z : D) : C ⥤ C × D 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (Z : D) (X : C)
Goal: (CategoryTheory.Prod.sectl C Z).obj X = (X, Z)
-- CategoryTheory.Prod.sectr_obj
@[simps]
def sectr {C : Type u₁} [Category.{v₁} C] (Z : C) (D : Type u₂) [Category.{v₂} D] : D ⥤ C × D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (Z : C) (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : D)
Goal: (CategoryTheory.Prod.sectr Z D).obj X = (Z, X)
-- CategoryTheory.Prod.sectr_map
@[simps]
def sectr {C : Type u₁} [Category.{v₁} C] (Z : C) (D : Type u₂) [Category.{v₂} D] : D ⥤ C × D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (Z : C) (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D]
Goal: ∀ {X Y : D} (f : X ⟶ Y), (CategoryTheory.Prod.sectr Z D).map f = (CategoryTheory.CategoryStruct.id Z, f)
-- CategoryTheory.Prod.fst_map
@[simps]
def fst : C × D ⥤ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D]
Goal: ∀ {X Y : C × D} (f : X ⟶ Y), (CategoryTheory.Prod.fst C D).map f = f.1
-- CategoryTheory.Prod.fst_obj
@[simps]
def fst : C × D ⥤ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : C × D)
Goal: (CategoryTheory.Prod.fst C D).obj X = X.1
-- CategoryTheory.Prod.snd_map
@[simps]
def snd : C × D ⥤ D 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D]
Goal: ∀ {X Y : C × D} (f : X ⟶ Y), (CategoryTheory.Prod.snd C D).map f = f.2
-- CategoryTheory.Prod.snd_obj
@[simps]
def snd : C × D ⥤ D 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : C × D)
Goal: (CategoryTheory.Prod.snd C D).obj X = X.2
-- CategoryTheory.Prod.swap_obj
@[simps]
def swap : C × D ⥤ D × C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : C × D)
Goal: (CategoryTheory.Prod.swap C D).obj X = (X.2, X.1)
-- CategoryTheory.Prod.swap_map
@[simps]
def swap : C × D ⥤ D × C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D]
Goal: ∀ {X Y : C × D} (f : X ⟶ Y), (CategoryTheory.Prod.swap C D).map f = (f.2, f.1)
-- CategoryTheory.Prod.symmetry_hom_app
@[simps]
def symmetry : swap C D ⋙ swap D C ≅ 𝟭 (C × D) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : C × D)
Goal: (CategoryTheory.Prod.symmetry C D).hom.app X = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Prod.symmetry_inv_app
@[simps]
def symmetry : swap C D ⋙ swap D C ≅ 𝟭 (C × D) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : C × D)
Goal: (CategoryTheory.Prod.symmetry C D).inv.app X = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Prod.braiding_inverse_map
@[simps!]
def braiding : C × D ≌ D × C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D]
Goal: ∀ {X Y : D × C} (f : X ⟶ Y), (CategoryTheory.Prod.braiding C D).inverse.map f = (f.2, f.1)
-- CategoryTheory.Prod.braiding_counitIso_hom_app
@[simps!]
def braiding : C × D ≌ D × C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : D × C)
Goal: (CategoryTheory.Prod.braiding C D).counitIso.hom.app X =
  (CategoryTheory.CategoryStruct.id X.1, CategoryTheory.CategoryStruct.id X.2)
-- CategoryTheory.Prod.braiding_unitIso_inv_app
@[simps!]
def braiding : C × D ≌ D × C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : C × D)
Goal: (CategoryTheory.Prod.braiding C D).unitIso.inv.app X =
  (CategoryTheory.CategoryStruct.id X.1, CategoryTheory.CategoryStruct.id X.2)
-- CategoryTheory.Prod.braiding_inverse_obj
@[simps!]
def braiding : C × D ≌ D × C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : D × C)
Goal: (CategoryTheory.Prod.braiding C D).inverse.obj X = (X.2, X.1)
-- CategoryTheory.Prod.braiding_counitIso_inv_app
@[simps!]
def braiding : C × D ≌ D × C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : D × C)
Goal: (CategoryTheory.Prod.braiding C D).counitIso.inv.app X =
  (CategoryTheory.CategoryStruct.id X.1, CategoryTheory.CategoryStruct.id X.2)
-- CategoryTheory.Prod.braiding_unitIso_hom_app
@[simps!]
def braiding : C × D ≌ D × C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : C × D)
Goal: (CategoryTheory.Prod.braiding C D).unitIso.hom.app X =
  (CategoryTheory.CategoryStruct.id X.1, CategoryTheory.CategoryStruct.id X.2)
-- CategoryTheory.Prod.braiding_functor_map
@[simps!]
def braiding : C × D ≌ D × C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D]
Goal: ∀ {X Y : C × D} (f : X ⟶ Y), (CategoryTheory.Prod.braiding C D).functor.map f = (f.2, f.1)
-- CategoryTheory.Prod.braiding_functor_obj
@[simps!]
def braiding : C × D ≌ D × C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : C × D)
Goal: (CategoryTheory.Prod.braiding C D).functor.obj X = (X.2, X.1)
-- CategoryTheory.evaluation_map_app
@[simps]
def evaluation : C ⥤ (C ⥤ D) ⥤ D 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] {X Y : C} (f : X ⟶ Y) (F : CategoryTheory.Functor C D)
Goal: ((CategoryTheory.evaluation C D).map f).app F = F.map f
-- CategoryTheory.evaluation_obj_map
@[simps]
def evaluation : C ⥤ (C ⥤ D) ⥤ D 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : C)
Goal: ∀ {X_1 Y : CategoryTheory.Functor C D} (α : X_1 ⟶ Y), ((CategoryTheory.evaluation C D).obj X).map α = α.app X
-- CategoryTheory.evaluation_obj_obj
@[simps]
def evaluation : C ⥤ (C ⥤ D) ⥤ D 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : C) (F : CategoryTheory.Functor C D)
Goal: ((CategoryTheory.evaluation C D).obj X).obj F = F.obj X
-- CategoryTheory.evaluationUncurried_map
@[simps]
def evaluationUncurried : C × (C ⥤ D) ⥤ D 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] {x y : C × CategoryTheory.Functor C D} (f : x ⟶ y)
Goal: (CategoryTheory.evaluationUncurried C D).map f = CategoryTheory.CategoryStruct.comp (x.2.map f.1) (f.2.app y.1)
-- CategoryTheory.evaluationUncurried_obj
@[simps]
def evaluationUncurried : C × (C ⥤ D) ⥤ D 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (p : C × CategoryTheory.Functor C D)
Goal: (CategoryTheory.evaluationUncurried C D).obj p = p.2.obj p.1
-- CategoryTheory.Functor.constCompEvaluationObj_hom_app
@[simps!]
def Functor.constCompEvaluationObj (X : C) : Functor.const C ⋙ (evaluation C D).obj X ≅ 𝟭 D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : C)
Goal: ∀ (X_1 : D), (CategoryTheory.Functor.constCompEvaluationObj D X).hom.app X_1 = CategoryTheory.CategoryStruct.id X_1
-- CategoryTheory.Functor.constCompEvaluationObj_inv_app
@[simps!]
def Functor.constCompEvaluationObj (X : C) : Functor.const C ⋙ (evaluation C D).obj X ≅ 𝟭 D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (X : C)
Goal: ∀ (X_1 : D), (CategoryTheory.Functor.constCompEvaluationObj D X).inv.app X_1 = CategoryTheory.CategoryStruct.id X_1
-- CategoryTheory.Functor.prod_obj
@[simps]
def prod (F : A ⥤ B) (G : C ⥤ D) : A × C ⥤ B × D 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] (F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C D) (X : A × C)
Goal: (F.prod G).obj X = (F.obj X.1, G.obj X.2)
-- CategoryTheory.Functor.prod_map
@[simps]
def prod (F : A ⥤ B) (G : C ⥤ D) : A × C ⥤ B × D 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] (F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C D)
Goal: ∀ {X Y : A × C} (f : X ⟶ Y), (F.prod G).map f = (F.map f.1, G.map f.2)
-- CategoryTheory.Functor.prod'_map
@[simps]
def prod' (F : A ⥤ B) (G : A ⥤ C) : A ⥤ B × C 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor A C)
Goal: ∀ {X Y : A} (f : X ⟶ Y), (F.prod' G).map f = (F.map f, G.map f)
-- CategoryTheory.Functor.prod'_obj
@[simps]
def prod' (F : A ⥤ B) (G : A ⥤ C) : A ⥤ B × C 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor A C) (a : A)
Goal: (F.prod' G).obj a = (F.obj a, G.obj a)
-- CategoryTheory.Functor.prod'CompFst_hom_app
@[simps!]
def prod'CompFst (F : A ⥤ B) (G : A ⥤ C) : F.prod' G ⋙ CategoryTheory.Prod.fst B C ≅ F 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor A C) (X : A)
Goal: (F.prod'CompFst G).hom.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Functor.prod'CompFst_inv_app
@[simps!]
def prod'CompFst (F : A ⥤ B) (G : A ⥤ C) : F.prod' G ⋙ CategoryTheory.Prod.fst B C ≅ F 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor A C) (X : A)
Goal: (F.prod'CompFst G).inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Functor.prod'CompSnd_hom_app
@[simps!]
def prod'CompSnd (F : A ⥤ B) (G : A ⥤ C) : F.prod' G ⋙ CategoryTheory.Prod.snd B C ≅ G 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor A C) (X : A)
Goal: (F.prod'CompSnd G).hom.app X = CategoryTheory.CategoryStruct.id (G.obj X)
-- CategoryTheory.Functor.prod'CompSnd_inv_app
@[simps!]
def prod'CompSnd (F : A ⥤ B) (G : A ⥤ C) : F.prod' G ⋙ CategoryTheory.Prod.snd B C ≅ G 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor A C) (X : A)
Goal: (F.prod'CompSnd G).inv.app X = CategoryTheory.CategoryStruct.id (G.obj X)
-- CategoryTheory.Functor.diag_obj
@[simp]
theorem diag_obj (X : C) : (diag C).obj X = (X, X) 
Arguments: (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] (X : C)
Goal: (CategoryTheory.Functor.diag C).obj X = (X, X)
-- CategoryTheory.Functor.diag_map
@[simp]
theorem diag_map {X Y : C} (f : X ⟶ Y) : (diag C).map f = (f, f) 
Arguments: (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Functor.diag C).map f = (f, f)
-- CategoryTheory.NatTrans.prod_app
@[simps]
def prod {F G : A ⥤ B} {H I : C ⥤ D} (α : F ⟶ G) (β : H ⟶ I) : F.prod H ⟶ G.prod I 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] {F G : CategoryTheory.Functor A B} {H I : CategoryTheory.Functor C D} (α : F ⟶ G) (β : H ⟶ I) (X : A × C)
Goal: (CategoryTheory.NatTrans.prod α β).app X = (α.app X.1, β.app X.2)
-- CategoryTheory.NatIso.prod_hom
@[simps]
def prod {F F' : A ⥤ B} {G G' : C ⥤ D} (e₁ : F ≅ F') (e₂ : G ≅ G') :
    F.prod G ≅ F'.prod G' 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] {F F' : CategoryTheory.Functor A B} {G G' : CategoryTheory.Functor C D} (e₁ : F ≅ F') (e₂ : G ≅ G')
Goal: (CategoryTheory.NatIso.prod e₁ e₂).hom = CategoryTheory.NatTrans.prod e₁.hom e₂.hom
-- CategoryTheory.NatIso.prod_inv
@[simps]
def prod {F F' : A ⥤ B} {G G' : C ⥤ D} (e₁ : F ≅ F') (e₂ : G ≅ G') :
    F.prod G ≅ F'.prod G' 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] {F F' : CategoryTheory.Functor A B} {G G' : CategoryTheory.Functor C D} (e₁ : F ≅ F') (e₂ : G ≅ G')
Goal: (CategoryTheory.NatIso.prod e₁ e₂).inv = CategoryTheory.NatTrans.prod e₁.inv e₂.inv
-- CategoryTheory.Equivalence.prod_functor
@[simps]
def prod (E₁ : A ≌ B) (E₂ : C ≌ D) : A × C ≌ B × D 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] (E₁ : A ≌ B) (E₂ : C ≌ D)
Goal: (E₁.prod E₂).functor = E₁.functor.prod E₂.functor