ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.BinaryFan.leftUnitor_hom
@[simps]
def BinaryFan.leftUnitor {X : C} {s : Cone (Functor.empty.{0} C)} (P : IsLimit s)
    {t : BinaryFan s.pt X} (Q : IsLimit t) : t.pt ≅ X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {s : CategoryTheory.Limits.Cone (CategoryTheory.Functor.empty C)} (P : CategoryTheory.Limits.IsLimit s) {t : CategoryTheory.Limits.BinaryFan s.pt X} (Q : CategoryTheory.Limits.IsLimit t)
Goal: (CategoryTheory.Limits.BinaryFan.leftUnitor P Q).hom = t.snd
-- CategoryTheory.Limits.BinaryFan.leftUnitor_inv
@[simps]
def BinaryFan.leftUnitor {X : C} {s : Cone (Functor.empty.{0} C)} (P : IsLimit s)
    {t : BinaryFan s.pt X} (Q : IsLimit t) : t.pt ≅ X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {s : CategoryTheory.Limits.Cone (CategoryTheory.Functor.empty C)} (P : CategoryTheory.Limits.IsLimit s) {t : CategoryTheory.Limits.BinaryFan s.pt X} (Q : CategoryTheory.Limits.IsLimit t)
Goal: (CategoryTheory.Limits.BinaryFan.leftUnitor P Q).inv =
  Q.lift
    (CategoryTheory.Limits.BinaryFan.mk (P.lift { pt := X, π := { app := fun x => x.as.elim, naturality := ⋯ } })
      (CategoryTheory.CategoryStruct.id { pt := X, π := { app := fun x => x.as.elim, naturality := ⋯ } }.pt))
-- CategoryTheory.Limits.BinaryFan.rightUnitor_inv
@[simps]
def BinaryFan.rightUnitor {X : C} {s : Cone (Functor.empty.{0} C)} (P : IsLimit s)
    {t : BinaryFan X s.pt} (Q : IsLimit t) : t.pt ≅ X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {s : CategoryTheory.Limits.Cone (CategoryTheory.Functor.empty C)} (P : CategoryTheory.Limits.IsLimit s) {t : CategoryTheory.Limits.BinaryFan X s.pt} (Q : CategoryTheory.Limits.IsLimit t)
Goal: (CategoryTheory.Limits.BinaryFan.rightUnitor P Q).inv =
  Q.lift
    (CategoryTheory.Limits.BinaryFan.mk (CategoryTheory.CategoryStruct.id X)
      (P.lift { pt := X, π := { app := fun x => x.as.elim, naturality := ⋯ } }))
-- CategoryTheory.Limits.BinaryFan.rightUnitor_hom
@[simps]
def BinaryFan.rightUnitor {X : C} {s : Cone (Functor.empty.{0} C)} (P : IsLimit s)
    {t : BinaryFan X s.pt} (Q : IsLimit t) : t.pt ≅ X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {s : CategoryTheory.Limits.Cone (CategoryTheory.Functor.empty C)} (P : CategoryTheory.Limits.IsLimit s) {t : CategoryTheory.Limits.BinaryFan X s.pt} (Q : CategoryTheory.Limits.IsLimit t)
Goal: (CategoryTheory.Limits.BinaryFan.rightUnitor P Q).hom = t.fst
-- CategoryTheory.MonoidalOfChosenFiniteProducts.tensor_id
theorem tensor_id (X₁ X₂ : C) : tensorHom ℬ (𝟙 X₁) (𝟙 X₂) = 𝟙 (tensorObj ℬ X₁ X₂) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (ℬ : (X Y : C) → CategoryTheory.Limits.LimitCone (CategoryTheory.Limits.pair X Y)) (X₁ X₂ : C)
Goal: CategoryTheory.MonoidalOfChosenFiniteProducts.tensorHom ℬ (CategoryTheory.CategoryStruct.id X₁)
    (CategoryTheory.CategoryStruct.id X₂) =
  CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalOfChosenFiniteProducts.tensorObj ℬ X₁ X₂)
-- CategoryTheory.MonoidalOfChosenFiniteProducts.tensor_comp
theorem tensor_comp {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (g₁ : Y₁ ⟶ Z₁)
    (g₂ : Y₂ ⟶ Z₂) : tensorHom ℬ (f₁ ≫ g₁) (f₂ ≫ g₂) = tensorHom ℬ f₁ f₂ ≫ tensorHom ℬ g₁ g₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (ℬ : (X Y : C) → CategoryTheory.Limits.LimitCone (CategoryTheory.Limits.pair X Y)) {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (g₁ : Y₁ ⟶ Z₁) (g₂ : Y₂ ⟶ Z₂)
Goal: CategoryTheory.MonoidalOfChosenFiniteProducts.tensorHom ℬ (CategoryTheory.CategoryStruct.comp f₁ g₁)
    (CategoryTheory.CategoryStruct.comp f₂ g₂) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalOfChosenFiniteProducts.tensorHom ℬ f₁ f₂)
    (CategoryTheory.MonoidalOfChosenFiniteProducts.tensorHom ℬ g₁ g₂)
-- CategoryTheory.MonoidalOfChosenFiniteProducts.pentagon
theorem pentagon (W X Y Z : C) :
    tensorHom ℬ (BinaryFan.associatorOfLimitCone ℬ W X Y).hom (𝟙 Z) ≫
        (BinaryFan.associatorOfLimitCone ℬ W (tensorObj ℬ X Y) Z).hom ≫
          tensorHom ℬ (𝟙 W) (BinaryFan.associatorOfLimitCone ℬ X Y Z).hom =
      (BinaryFan.associatorOfLimitCone ℬ (tensorObj ℬ W X) Y Z).hom ≫
        (BinaryFan.associatorOfLimitCone ℬ W X (tensorObj ℬ Y Z)).hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (ℬ : (X Y : C) → CategoryTheory.Limits.LimitCone (CategoryTheory.Limits.pair X Y)) (W X Y Z : C)
Goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.MonoidalOfChosenFiniteProducts.tensorHom ℬ
      (CategoryTheory.Limits.BinaryFan.associatorOfLimitCone ℬ W X Y).hom (CategoryTheory.CategoryStruct.id Z))
    (CategoryTheory.CategoryStruct.comp
      (CategoryTheory.Limits.BinaryFan.associatorOfLimitCone ℬ W
          (CategoryTheory.MonoidalOfChosenFiniteProducts.tensorObj ℬ X Y) Z).hom
      (CategoryTheory.MonoidalOfChosenFiniteProducts.tensorHom ℬ (CategoryTheory.CategoryStruct.id W)
        (CategoryTheory.Limits.BinaryFan.associatorOfLimitCone ℬ X Y Z).hom)) =
  CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Limits.BinaryFan.associatorOfLimitCone ℬ
        (CategoryTheory.MonoidalOfChosenFiniteProducts.tensorObj ℬ W X) Y Z).hom
    (CategoryTheory.Limits.BinaryFan.associatorOfLimitCone ℬ W X
        (CategoryTheory.MonoidalOfChosenFiniteProducts.tensorObj ℬ Y Z)).hom
-- CategoryTheory.MonoidalOfChosenFiniteProducts.triangle
theorem triangle (X Y : C) :
    (BinaryFan.associatorOfLimitCone ℬ X 𝒯.cone.pt Y).hom ≫
        tensorHom ℬ (𝟙 X) (BinaryFan.leftUnitor 𝒯.isLimit (ℬ 𝒯.cone.pt Y).isLimit).hom =
      tensorHom ℬ (BinaryFan.rightUnitor 𝒯.isLimit (ℬ X 𝒯.cone.pt).isLimit).hom (𝟙 Y) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (𝒯 : CategoryTheory.Limits.LimitCone (CategoryTheory.Functor.empty C)) (ℬ : (X Y : C) → CategoryTheory.Limits.LimitCone (CategoryTheory.Limits.pair X Y)) (X Y : C)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.BinaryFan.associatorOfLimitCone ℬ X 𝒯.cone.pt Y).hom
    (CategoryTheory.MonoidalOfChosenFiniteProducts.tensorHom ℬ (CategoryTheory.CategoryStruct.id X)
      (CategoryTheory.Limits.BinaryFan.leftUnitor 𝒯.isLimit (ℬ 𝒯.cone.pt Y).isLimit).hom) =
  CategoryTheory.MonoidalOfChosenFiniteProducts.tensorHom ℬ
    (CategoryTheory.Limits.BinaryFan.rightUnitor 𝒯.isLimit (ℬ X 𝒯.cone.pt).isLimit).hom
    (CategoryTheory.CategoryStruct.id Y)
-- CategoryTheory.MonoidalOfChosenFiniteProducts.leftUnitor_naturality
theorem leftUnitor_naturality {X₁ X₂ : C} (f : X₁ ⟶ X₂) :
    tensorHom ℬ (𝟙 𝒯.cone.pt) f ≫ (BinaryFan.leftUnitor 𝒯.isLimit (ℬ 𝒯.cone.pt X₂).isLimit).hom =
      (BinaryFan.leftUnitor 𝒯.isLimit (ℬ 𝒯.cone.pt X₁).isLimit).hom ≫ f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (𝒯 : CategoryTheory.Limits.LimitCone (CategoryTheory.Functor.empty C)) (ℬ : (X Y : C) → CategoryTheory.Limits.LimitCone (CategoryTheory.Limits.pair X Y)) {X₁ X₂ : C} (f : X₁ ⟶ X₂)
Goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.MonoidalOfChosenFiniteProducts.tensorHom ℬ (CategoryTheory.CategoryStruct.id 𝒯.cone.pt) f)
    (CategoryTheory.Limits.BinaryFan.leftUnitor 𝒯.isLimit (ℬ 𝒯.cone.pt X₂).isLimit).hom =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.BinaryFan.leftUnitor 𝒯.isLimit (ℬ 𝒯.cone.pt X₁).isLimit).hom
    f
-- CategoryTheory.MonoidalOfChosenFiniteProducts.rightUnitor_naturality
theorem rightUnitor_naturality {X₁ X₂ : C} (f : X₁ ⟶ X₂) :
    tensorHom ℬ f (𝟙 𝒯.cone.pt) ≫ (BinaryFan.rightUnitor 𝒯.isLimit (ℬ X₂ 𝒯.cone.pt).isLimit).hom =
      (BinaryFan.rightUnitor 𝒯.isLimit (ℬ X₁ 𝒯.cone.pt).isLimit).hom ≫ f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (𝒯 : CategoryTheory.Limits.LimitCone (CategoryTheory.Functor.empty C)) (ℬ : (X Y : C) → CategoryTheory.Limits.LimitCone (CategoryTheory.Limits.pair X Y)) {X₁ X₂ : C} (f : X₁ ⟶ X₂)
Goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.MonoidalOfChosenFiniteProducts.tensorHom ℬ f (CategoryTheory.CategoryStruct.id 𝒯.cone.pt))
    (CategoryTheory.Limits.BinaryFan.rightUnitor 𝒯.isLimit (ℬ X₂ 𝒯.cone.pt).isLimit).hom =
  CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Limits.BinaryFan.rightUnitor 𝒯.isLimit (ℬ X₁ 𝒯.cone.pt).isLimit).hom f
-- CategoryTheory.MonoidalOfChosenFiniteProducts.associator_naturality
theorem associator_naturality {X₁ X₂ X₃ Y₁ Y₂ Y₃ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃ : X₃ ⟶ Y₃) :
    tensorHom ℬ (tensorHom ℬ f₁ f₂) f₃ ≫ (BinaryFan.associatorOfLimitCone ℬ Y₁ Y₂ Y₃).hom =
      (BinaryFan.associatorOfLimitCone ℬ X₁ X₂ X₃).hom ≫ tensorHom ℬ f₁ (tensorHom ℬ f₂ f₃) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (ℬ : (X Y : C) → CategoryTheory.Limits.LimitCone (CategoryTheory.Limits.pair X Y)) {X₁ X₂ X₃ Y₁ Y₂ Y₃ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃ : X₃ ⟶ Y₃)
Goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.MonoidalOfChosenFiniteProducts.tensorHom ℬ
      (CategoryTheory.MonoidalOfChosenFiniteProducts.tensorHom ℬ f₁ f₂) f₃)
    (CategoryTheory.Limits.BinaryFan.associatorOfLimitCone ℬ Y₁ Y₂ Y₃).hom =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.BinaryFan.associatorOfLimitCone ℬ X₁ X₂ X₃).hom
    (CategoryTheory.MonoidalOfChosenFiniteProducts.tensorHom ℬ f₁
      (CategoryTheory.MonoidalOfChosenFiniteProducts.tensorHom ℬ f₂ f₃))
-- CategoryTheory.Discrete.monoidal_tensorObj_as
@[to_additive (attr := simps tensorObj_as leftUnitor rightUnitor associator) Discrete.addMonoidal]
instance Discrete.monoidal : MonoidalCategory (Discrete M) 
Arguments: (M : Type u) [Monoid M] (X Y : CategoryTheory.Discrete M)
Goal: (X ⊗ Y).as = X.as * Y.as
-- CategoryTheory.Discrete.addMonoidal_associator
@[to_additive (attr := simps tensorObj_as leftUnitor rightUnitor associator) Discrete.addMonoidal]
instance Discrete.monoidal : MonoidalCategory (Discrete M) 
Arguments: (M : Type u) [AddMonoid M] (X Y Z : CategoryTheory.Discrete M)
Goal: α_ X Y Z = CategoryTheory.Discrete.eqToIso ⋯
-- CategoryTheory.Discrete.addMonoidal_leftUnitor
@[to_additive (attr := simps tensorObj_as leftUnitor rightUnitor associator) Discrete.addMonoidal]
instance Discrete.monoidal : MonoidalCategory (Discrete M) 
Arguments: (M : Type u) [AddMonoid M] (X : CategoryTheory.Discrete M)
Goal: λ_ X = CategoryTheory.Discrete.eqToIso ⋯
-- CategoryTheory.Discrete.monoidal_leftUnitor
@[to_additive (attr := simps tensorObj_as leftUnitor rightUnitor associator) Discrete.addMonoidal]
instance Discrete.monoidal : MonoidalCategory (Discrete M) 
Arguments: (M : Type u) [Monoid M] (X : CategoryTheory.Discrete M)
Goal: λ_ X = CategoryTheory.Discrete.eqToIso ⋯
-- CategoryTheory.Discrete.addMonoidal_tensorObj_as
@[to_additive (attr := simps tensorObj_as leftUnitor rightUnitor associator) Discrete.addMonoidal]
instance Discrete.monoidal : MonoidalCategory (Discrete M) 
Arguments: (M : Type u) [AddMonoid M] (X Y : CategoryTheory.Discrete M)
Goal: (X ⊗ Y).as = X.as + Y.as
-- CategoryTheory.Discrete.monoidal_associator
@[to_additive (attr := simps tensorObj_as leftUnitor rightUnitor associator) Discrete.addMonoidal]
instance Discrete.monoidal : MonoidalCategory (Discrete M) 
Arguments: (M : Type u) [Monoid M] (X Y Z : CategoryTheory.Discrete M)
Goal: α_ X Y Z = CategoryTheory.Discrete.eqToIso ⋯
-- CategoryTheory.Discrete.monoidal_rightUnitor
@[to_additive (attr := simps tensorObj_as leftUnitor rightUnitor associator) Discrete.addMonoidal]
instance Discrete.monoidal : MonoidalCategory (Discrete M) 
Arguments: (M : Type u) [Monoid M] (X : CategoryTheory.Discrete M)
Goal: ρ_ X = CategoryTheory.Discrete.eqToIso ⋯
-- CategoryTheory.Discrete.addMonoidal_rightUnitor
@[to_additive (attr := simps tensorObj_as leftUnitor rightUnitor associator) Discrete.addMonoidal]
instance Discrete.monoidal : MonoidalCategory (Discrete M) 
Arguments: (M : Type u) [AddMonoid M] (X : CategoryTheory.Discrete M)
Goal: ρ_ X = CategoryTheory.Discrete.eqToIso ⋯
-- CategoryTheory.Discrete.monoidal_tensorUnit_as
@[to_additive (attr := simp) Discrete.addMonoidal_tensorUnit_as]
lemma Discrete.monoidal_tensorUnit_as : (𝟙_ (Discrete M)).as = 1 
Arguments: (M : Type u) [Monoid M]
Goal: (𝟙_ (CategoryTheory.Discrete M)).as = 1
-- CategoryTheory.Discrete.addMonoidal_tensorUnit_as
@[to_additive (attr := simp) Discrete.addMonoidal_tensorUnit_as]
lemma Discrete.monoidal_tensorUnit_as : (𝟙_ (Discrete M)).as = 1 
Arguments: (M : Type u) [AddMonoid M]
Goal: (𝟙_ (CategoryTheory.Discrete M)).as = 0
-- CategoryTheory.Discrete.addMonoidalFunctor_toLaxMonoidalFunctor_μ
@[to_additive (attr := simps) Discrete.addMonoidalFunctor]
def Discrete.monoidalFunctor (F : M →* N) : MonoidalFunctor (Discrete M) (Discrete N) 
Arguments: {M : Type u} [AddMonoid M] {N : Type u'} [AddMonoid N] (F : M →+ N) (X Y : CategoryTheory.Discrete M)
Goal: (CategoryTheory.Discrete.addMonoidalFunctor F).μ X Y = CategoryTheory.Discrete.eqToHom ⋯
-- CategoryTheory.Discrete.addMonoidalFunctor_toLaxMonoidalFunctor_toFunctor_map
@[to_additive (attr := simps) Discrete.addMonoidalFunctor]
def Discrete.monoidalFunctor (F : M →* N) : MonoidalFunctor (Discrete M) (Discrete N) 
Arguments: {M : Type u} [AddMonoid M] {N : Type u'} [AddMonoid N] (F : M →+ N)
Goal: ∀ {X Y : CategoryTheory.Discrete M} (f : X ⟶ Y),
  (CategoryTheory.Discrete.addMonoidalFunctor F).map f = CategoryTheory.Discrete.eqToHom ⋯
-- CategoryTheory.Discrete.monoidalFunctor_toLaxMonoidalFunctor_μ
@[to_additive (attr := simps) Discrete.addMonoidalFunctor]
def Discrete.monoidalFunctor (F : M →* N) : MonoidalFunctor (Discrete M) (Discrete N) 
Arguments: {M : Type u} [Monoid M] {N : Type u'} [Monoid N] (F : M →* N) (X Y : CategoryTheory.Discrete M)
Goal: (CategoryTheory.Discrete.monoidalFunctor F).μ X Y = CategoryTheory.Discrete.eqToHom ⋯
-- CategoryTheory.Discrete.addMonoidalFunctor_toLaxMonoidalFunctor_toFunctor_obj_as
@[to_additive (attr := simps) Discrete.addMonoidalFunctor]
def Discrete.monoidalFunctor (F : M →* N) : MonoidalFunctor (Discrete M) (Discrete N) 
Arguments: {M : Type u} [AddMonoid M] {N : Type u'} [AddMonoid N] (F : M →+ N) (X : CategoryTheory.Discrete M)
Goal: ((CategoryTheory.Discrete.addMonoidalFunctor F).obj X).as = F X.as
-- CategoryTheory.Discrete.addMonoidalFunctor_toLaxMonoidalFunctor_ε
@[to_additive (attr := simps) Discrete.addMonoidalFunctor]
def Discrete.monoidalFunctor (F : M →* N) : MonoidalFunctor (Discrete M) (Discrete N) 
Arguments: {M : Type u} [AddMonoid M] {N : Type u'} [AddMonoid N] (F : M →+ N)
Goal: (CategoryTheory.Discrete.addMonoidalFunctor F).ε = CategoryTheory.Discrete.eqToHom ⋯
-- CategoryTheory.Discrete.monoidalFunctor_toLaxMonoidalFunctor_toFunctor_obj_as
@[to_additive (attr := simps) Discrete.addMonoidalFunctor]
def Discrete.monoidalFunctor (F : M →* N) : MonoidalFunctor (Discrete M) (Discrete N) 
Arguments: {M : Type u} [Monoid M] {N : Type u'} [Monoid N] (F : M →* N) (X : CategoryTheory.Discrete M)
Goal: ((CategoryTheory.Discrete.monoidalFunctor F).obj X).as = F X.as
-- CategoryTheory.Discrete.monoidalFunctor_toLaxMonoidalFunctor_toFunctor_map
@[to_additive (attr := simps) Discrete.addMonoidalFunctor]
def Discrete.monoidalFunctor (F : M →* N) : MonoidalFunctor (Discrete M) (Discrete N) 
Arguments: {M : Type u} [Monoid M] {N : Type u'} [Monoid N] (F : M →* N)
Goal: ∀ {X Y : CategoryTheory.Discrete M} (f : X ⟶ Y),
  (CategoryTheory.Discrete.monoidalFunctor F).map f = CategoryTheory.Discrete.eqToHom ⋯
-- CategoryTheory.Discrete.monoidalFunctor_toLaxMonoidalFunctor_ε
@[to_additive (attr := simps) Discrete.addMonoidalFunctor]
def Discrete.monoidalFunctor (F : M →* N) : MonoidalFunctor (Discrete M) (Discrete N) 
Arguments: {M : Type u} [Monoid M] {N : Type u'} [Monoid N] (F : M →* N)
Goal: (CategoryTheory.Discrete.monoidalFunctor F).ε = CategoryTheory.Discrete.eqToHom ⋯
-- FintypeCat.incl_map
@[simps!]
def incl : FintypeCat ⥤ Type* 
Goal: ∀ {X Y : CategoryTheory.InducedCategory (Type u_1) CategoryTheory.Bundled.α} (f : X ⟶ Y) (a : ↑X),
  FintypeCat.incl.map f a = f a
-- FintypeCat.incl_obj
@[simps!]
def incl : FintypeCat ⥤ Type* 
Arguments: (self : CategoryTheory.Bundled Fintype)
Goal: FintypeCat.incl.obj self = ↑self
-- FintypeCat.id_apply
@[simp]
theorem id_apply (X : FintypeCat) (x : X) : (𝟙 X : X → X) x = x 
Arguments: (X : FintypeCat) (x : ↑X)
Goal: 𝟙 X x = x
-- FintypeCat.comp_apply
@[simp]
theorem comp_apply {X Y Z : FintypeCat} (f : X ⟶ Y) (g : Y ⟶ Z) (x : X) : (f ≫ g) x = g (f x) 
Arguments: {X Y Z : FintypeCat} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X)
Goal: (f ≫ g) x = g (f x)
-- FintypeCat.hom_inv_id_apply
@[simp]
lemma hom_inv_id_apply {X Y : FintypeCat} (f : X ≅ Y) (x : X) : f.inv (f.hom x) = x 
Arguments: {X Y : FintypeCat} (f : X ≅ Y) (x : ↑X)
Goal: f.inv (f.hom x) = x
-- FintypeCat.inv_hom_id_apply
@[simp]
lemma inv_hom_id_apply {X Y : FintypeCat} (f : X ≅ Y) (y : Y) : f.hom (f.inv y) = y 
Arguments: {X Y : FintypeCat} (f : X ≅ Y) (y : ↑Y)
Goal: f.hom (f.inv y) = y
-- FintypeCat.hom_ext
@[ext]
lemma hom_ext {X Y : FintypeCat} (f g : X ⟶ Y) (h : ∀ x, f x = g x) : f = g 
Arguments: {X Y : FintypeCat} (f g : X ⟶ Y) (h : ∀ (x : ↑X), f x = g x)
Goal: f = g
-- FintypeCat.equivEquivIso_apply_inv
@[simps]
def equivEquivIso {A B : FintypeCat} : A ≃ B ≃ (A ≅ B) 
Arguments: {A B : FintypeCat} (e : ↑A ≃ ↑B) (a : ↑B)
Goal: (FintypeCat.equivEquivIso e).inv a = e.symm a
-- FintypeCat.equivEquivIso_symm_apply_apply
@[simps]
def equivEquivIso {A B : FintypeCat} : A ≃ B ≃ (A ≅ B) 
Arguments: {A B : FintypeCat} (i : A ≅ B)
Goal: ∀ (a : ↑A), (FintypeCat.equivEquivIso.symm i) a = i.hom a
-- FintypeCat.equivEquivIso_symm_apply_symm_apply
@[simps]
def equivEquivIso {A B : FintypeCat} : A ≃ B ≃ (A ≅ B) 
Arguments: {A B : FintypeCat} (i : A ≅ B)
Goal: ∀ (a : ↑B), (FintypeCat.equivEquivIso.symm i).symm a = i.inv a
-- FintypeCat.equivEquivIso_apply_hom
@[simps]
def equivEquivIso {A B : FintypeCat} : A ≃ B ≃ (A ≅ B) 
Arguments: {A B : FintypeCat} (e : ↑A ≃ ↑B) (a : ↑A)
Goal: (FintypeCat.equivEquivIso e).hom a = e a
-- FintypeCat.Skeleton.ext
@[ext]
theorem ext (X Y : Skeleton) : X.len = Y.len → X = Y 
Arguments: (X Y : FintypeCat.Skeleton)
Goal: X.len = Y.len → X = Y
-- FintypeCat.Skeleton.is_skeletal
theorem is_skeletal : Skeletal Skeleton.{u} 
Goal: CategoryTheory.Skeletal FintypeCat.Skeleton
-- FintypeCat.Skeleton.incl_mk_nat_card
@[simp]
theorem incl_mk_nat_card (n : ℕ) : Fintype.card (incl.obj (mk n)) = n 
Arguments: (n : ℕ)
Goal: Fintype.card ↑(FintypeCat.Skeleton.incl.obj (FintypeCat.Skeleton.mk n)) = n
-- FintypeCat.isSkeleton
lemma isSkeleton : IsSkeletonOf FintypeCat Skeleton Skeleton.incl 
Goal: CategoryTheory.IsSkeletonOf FintypeCat FintypeCat.Skeleton FintypeCat.Skeleton.incl
-- CategoryTheory.CountableCategory.countableObj
class CountableCategory (J : Type*) [Category J] : Prop where
  countableObj : Countable J := by infer_instance
  countableHom : ∀ j j' : J, Countable (j ⟶ j') := by infer_instance
Arguments: {J : Type u_1} [CategoryTheory.Category.{u_2, u_1} J] [self : CategoryTheory.CountableCategory J]
Goal: Countable J
-- CategoryTheory.CountableCategory.countableHom
class CountableCategory (J : Type*) [Category J] : Prop where
  countableObj : Countable J := by infer_instance
  countableHom : ∀ j j' : J, Countable (j ⟶ j') := by infer_instance
Arguments: {J : Type u_1} [CategoryTheory.Category.{u_2, u_1} J] [self : CategoryTheory.CountableCategory J] (j j' : J)
Goal: Countable (j ⟶ j')
-- CategoryTheory.CommSq.w
structure CommSq {W X Y Z : C} (f : W ⟶ X) (g : W ⟶ Y) (h : X ⟶ Z) (i : Y ⟶ Z) : Prop where
    w : f ≫ h = g ≫ i
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} (self : CategoryTheory.CommSq f g h i)
Goal: CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g i
-- CategoryTheory.CommSq.flip
theorem flip (p : CommSq f g h i) : CommSq g f i h 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} (p : CategoryTheory.CommSq f g h i)
Goal: CategoryTheory.CommSq g f i h
-- CategoryTheory.CommSq.of_arrow
theorem of_arrow {f g : Arrow C} (h : f ⟶ g) : CommSq f.hom h.left h.right g.hom 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {f g : CategoryTheory.Arrow C} (h : f ⟶ g)
Goal: CategoryTheory.CommSq f.hom h.left h.right g.hom
-- CategoryTheory.CommSq.op
theorem op (p : CommSq f g h i) : CommSq i.op h.op g.op f.op 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} (p : CategoryTheory.CommSq f g h i)
Goal: CategoryTheory.CommSq i.op h.op g.op f.op
-- CategoryTheory.CommSq.unop
theorem unop {W X Y Z : Cᵒᵖ} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} (p : CommSq f g h i) :
    CommSq i.unop h.unop g.unop f.unop 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W X Y Z : Cᵒᵖ} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} (p : CategoryTheory.CommSq f g h i)
Goal: CategoryTheory.CommSq i.unop h.unop g.unop f.unop
-- CategoryTheory.CommSq.vert_inv
theorem vert_inv {g : W ≅ Y} {h : X ≅ Z} (p : CommSq f g.hom h.hom i) :
    CommSq i g.inv h.inv f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W X Y Z : C} {f : W ⟶ X} {i : Y ⟶ Z} {g : W ≅ Y} {h : X ≅ Z} (p : CategoryTheory.CommSq f g.hom h.hom i)
Goal: CategoryTheory.CommSq i g.inv h.inv f
-- CategoryTheory.CommSq.horiz_inv
theorem horiz_inv {f : W ≅ X} {i : Y ≅ Z} (p : CommSq f.hom g h i.hom) :
    CommSq f.inv h g i.inv 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W X Y Z : C} {g : W ⟶ Y} {h : X ⟶ Z} {f : W ≅ X} {i : Y ≅ Z} (p : CategoryTheory.CommSq f.hom g h i.hom)
Goal: CategoryTheory.CommSq f.inv h g i.inv
-- CategoryTheory.CommSq.horiz_comp
lemma horiz_comp {W X X' Y Z Z' : C} {f : W ⟶ X} {f' : X ⟶ X'} {g : W ⟶ Y} {h : X ⟶ Z}
    {h' : X' ⟶ Z'} {i : Y ⟶ Z} {i' : Z ⟶ Z'} (hsq₁ : CommSq f g h i) (hsq₂ : CommSq f' h h' i') :
    CommSq (f ≫ f') g h' (i ≫ i') 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W X X' Y Z Z' : C} {f : W ⟶ X} {f' : X ⟶ X'} {g : W ⟶ Y} {h : X ⟶ Z} {h' : X' ⟶ Z'} {i : Y ⟶ Z} {i' : Z ⟶ Z'} (hsq₁ : CategoryTheory.CommSq f g h i) (hsq₂ : CategoryTheory.CommSq f' h h' i')
Goal: CategoryTheory.CommSq (CategoryTheory.CategoryStruct.comp f f') g h' (CategoryTheory.CategoryStruct.comp i i')
-- CategoryTheory.CommSq.vert_comp
lemma vert_comp {W X Y Y' Z Z' : C} {f : W ⟶ X} {g : W ⟶ Y} {g' : Y ⟶ Y'} {h : X ⟶ Z}
    {h' : Z ⟶ Z'} {i : Y ⟶ Z} {i' : Y' ⟶ Z'} (hsq₁ : CommSq f g h i) (hsq₂ : CommSq i g' h' i') :
    CommSq f (g ≫ g') (h ≫ h') i' 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W X Y Y' Z Z' : C} {f : W ⟶ X} {g : W ⟶ Y} {g' : Y ⟶ Y'} {h : X ⟶ Z} {h' : Z ⟶ Z'} {i : Y ⟶ Z} {i' : Y' ⟶ Z'} (hsq₁ : CategoryTheory.CommSq f g h i) (hsq₂ : CategoryTheory.CommSq i g' h' i')
Goal: CategoryTheory.CommSq f (CategoryTheory.CategoryStruct.comp g g') (CategoryTheory.CategoryStruct.comp h h') i'
-- CategoryTheory.Functor.map_commSq
theorem map_commSq (s : CommSq f g h i) : CommSq (F.map f) (F.map g) (F.map h) (F.map i) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] (F : CategoryTheory.Functor C D) {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} (s : CategoryTheory.CommSq f g h i)
Goal: CategoryTheory.CommSq (F.map f) (F.map g) (F.map h) (F.map i)
-- CategoryTheory.CommSq.LiftStruct.fac_left
-- porting note (#5171): removed @[nolint has_nonempty_instance]
@[ext]
structure LiftStruct (sq : CommSq f i p g) where
    l : B ⟶ X
    fac_left : i ≫ l = f
    fac_right : l ≫ p = g
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y} {sq : CategoryTheory.CommSq f i p g} (self : sq.LiftStruct)
Goal: CategoryTheory.CategoryStruct.comp i self.l = f
-- CategoryTheory.CommSq.LiftStruct.fac_right
-- porting note (#5171): removed @[nolint has_nonempty_instance]
@[ext]
structure LiftStruct (sq : CommSq f i p g) where
    l : B ⟶ X
    fac_left : i ≫ l = f
    fac_right : l ≫ p = g
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y} {sq : CategoryTheory.CommSq f i p g} (self : sq.LiftStruct)
Goal: CategoryTheory.CategoryStruct.comp self.l p = g