ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.WithInitial.map_obj
@[simps]
def map {D : Type*} [Category D] (F : C ⥤ D) : WithInitial C ⥤ WithInitial D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] (F : CategoryTheory.Functor C D) (X : CategoryTheory.WithInitial C)
Goal: (CategoryTheory.WithInitial.map F).obj X =
  match X with
  | CategoryTheory.WithInitial.of x => CategoryTheory.WithInitial.of (F.obj x)
  | CategoryTheory.WithInitial.star => CategoryTheory.WithInitial.star
-- CategoryTheory.WithInitial.map_map
@[simps]
def map {D : Type*} [Category D] (F : C ⥤ D) : WithInitial C ⥤ WithInitial D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] (F : CategoryTheory.Functor C D) {X Y : CategoryTheory.WithInitial C} (f : X ⟶ Y)
Goal: (CategoryTheory.WithInitial.map F).map f =
  match X, Y, f with
  | CategoryTheory.WithInitial.of x, CategoryTheory.WithInitial.of y, f => F.map (CategoryTheory.WithInitial.down f)
  | CategoryTheory.WithInitial.star, CategoryTheory.WithInitial.of a, x => PUnit.unit
  | CategoryTheory.WithInitial.star, CategoryTheory.WithInitial.star, x => PUnit.unit
-- CategoryTheory.WithInitial.mapId_inv_app
@[simps!]
def mapId (C : Type*) [Category C] : map (𝟭 C) ≅ 𝟭 (WithInitial C) 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (X : CategoryTheory.WithInitial C)
Goal: (CategoryTheory.WithInitial.mapId C).inv.app X =
  (match X with
    | CategoryTheory.WithInitial.of x => CategoryTheory.Iso.refl (CategoryTheory.WithInitial.of x)
    | CategoryTheory.WithInitial.star => CategoryTheory.Iso.refl CategoryTheory.WithInitial.star).inv
-- CategoryTheory.WithInitial.mapId_hom_app
@[simps!]
def mapId (C : Type*) [Category C] : map (𝟭 C) ≅ 𝟭 (WithInitial C) 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (X : CategoryTheory.WithInitial C)
Goal: (CategoryTheory.WithInitial.mapId C).hom.app X =
  (match X with
    | CategoryTheory.WithInitial.of x => CategoryTheory.Iso.refl (CategoryTheory.WithInitial.of x)
    | CategoryTheory.WithInitial.star => CategoryTheory.Iso.refl CategoryTheory.WithInitial.star).hom
-- CategoryTheory.WithInitial.mapComp_inv_app
@[simps!]
def mapComp {D E : Type*} [Category D] [Category E] (F : C ⥤ D) (G : D ⥤ E) :
    map (F ⋙ G) ≅ map F ⋙ map G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} {E : Type u_2} [CategoryTheory.Category.{u_3, u_1} D] [CategoryTheory.Category.{u_4, u_2} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) (X : CategoryTheory.WithInitial C)
Goal: (CategoryTheory.WithInitial.mapComp F G).inv.app X =
  (match X with
    | CategoryTheory.WithInitial.of x => CategoryTheory.Iso.refl (CategoryTheory.WithInitial.of (G.obj (F.obj x)))
    | CategoryTheory.WithInitial.star => CategoryTheory.Iso.refl CategoryTheory.WithInitial.star).inv
-- CategoryTheory.WithInitial.mapComp_hom_app
@[simps!]
def mapComp {D E : Type*} [Category D] [Category E] (F : C ⥤ D) (G : D ⥤ E) :
    map (F ⋙ G) ≅ map F ⋙ map G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} {E : Type u_2} [CategoryTheory.Category.{u_3, u_1} D] [CategoryTheory.Category.{u_4, u_2} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) (X : CategoryTheory.WithInitial C)
Goal: (CategoryTheory.WithInitial.mapComp F G).hom.app X =
  (match X with
    | CategoryTheory.WithInitial.of x => CategoryTheory.Iso.refl (CategoryTheory.WithInitial.of (G.obj (F.obj x)))
    | CategoryTheory.WithInitial.star => CategoryTheory.Iso.refl CategoryTheory.WithInitial.star).hom
-- CategoryTheory.WithInitial.map₂_app
@[simps]
def map₂ {D : Type*} [Category D] {F G : C ⥤ D} (η : F ⟶ G) : map F ⟶ map G 
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} (η : F ⟶ G) (X : CategoryTheory.WithInitial C)
Goal: (CategoryTheory.WithInitial.map₂ η).app X =
  match X with
  | CategoryTheory.WithInitial.of x => η.app x
  | CategoryTheory.WithInitial.star => CategoryTheory.CategoryStruct.id CategoryTheory.WithInitial.star
-- CategoryTheory.WithInitial.prelaxfunctor_toPrelaxFunctorStruct_toPrefunctor_obj
@[simps]
def prelaxfunctor : PrelaxFunctor Cat Cat 
Arguments: (C : CategoryTheory.Cat)
Goal: CategoryTheory.WithInitial.prelaxfunctor.obj C = CategoryTheory.Cat.of (CategoryTheory.WithInitial ↑C)
-- CategoryTheory.WithInitial.prelaxfunctor_toPrelaxFunctorStruct_toPrefunctor_map
@[simps]
def prelaxfunctor : PrelaxFunctor Cat Cat 
Goal: ∀ {X Y : CategoryTheory.Cat} (F : CategoryTheory.Functor ↑X ↑Y),
  CategoryTheory.WithInitial.prelaxfunctor.map F = CategoryTheory.WithInitial.map F
-- CategoryTheory.WithInitial.prelaxfunctor_toPrelaxFunctorStruct_map₂
@[simps]
def prelaxfunctor : PrelaxFunctor Cat Cat 
Goal: ∀ {a b : CategoryTheory.Cat} {f g : a ⟶ b} (η : f ⟶ g),
  CategoryTheory.WithInitial.prelaxfunctor.map₂ η = CategoryTheory.WithInitial.map₂ η
-- CategoryTheory.WithInitial.pseudofunctor_toPrelaxFunctor
@[simps]
def pseudofunctor : Pseudofunctor Cat Cat 
Goal: CategoryTheory.WithInitial.pseudofunctor.toPrelaxFunctor = CategoryTheory.WithInitial.prelaxfunctor
-- CategoryTheory.WithInitial.pseudofunctor_mapComp
@[simps]
def pseudofunctor : Pseudofunctor Cat Cat 
Goal: ∀ {a b c : CategoryTheory.Cat} (F : CategoryTheory.Functor ↑a ↑b) (G : CategoryTheory.Functor ↑b ↑c),
  CategoryTheory.WithInitial.pseudofunctor.mapComp F G = CategoryTheory.WithInitial.mapComp F G
-- CategoryTheory.WithInitial.pseudofunctor_mapId
@[simps]
def pseudofunctor : Pseudofunctor Cat Cat 
Arguments: (C : CategoryTheory.Cat)
Goal: CategoryTheory.WithInitial.pseudofunctor.mapId C = CategoryTheory.WithInitial.mapId ↑C
-- CategoryTheory.WithInitial.lift_map
@[simps]
def lift {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (M : ∀ x : C, Z ⟶ F.obj x)
    (hM : ∀ (x y : C) (f : x ⟶ y), M x ≫ F.map f = M y) : WithInitial C ⥤ D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → Z ⟶ F.obj x) (hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (M x) (F.map f) = M y) {X Y : CategoryTheory.WithInitial C} (f : X ⟶ Y)
Goal: (CategoryTheory.WithInitial.lift F M hM).map f =
  match X, Y, f with
  | CategoryTheory.WithInitial.of x, CategoryTheory.WithInitial.of y, f => F.map (CategoryTheory.WithInitial.down f)
  | CategoryTheory.WithInitial.star, CategoryTheory.WithInitial.of x, x_1 => M x
  | CategoryTheory.WithInitial.star, CategoryTheory.WithInitial.star, x =>
    CategoryTheory.CategoryStruct.id
      ((fun X =>
          match X with
          | CategoryTheory.WithInitial.of x => F.obj x
          | CategoryTheory.WithInitial.star => Z)
        CategoryTheory.WithInitial.star)
-- CategoryTheory.WithInitial.lift_obj
@[simps]
def lift {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (M : ∀ x : C, Z ⟶ F.obj x)
    (hM : ∀ (x y : C) (f : x ⟶ y), M x ≫ F.map f = M y) : WithInitial C ⥤ D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → Z ⟶ F.obj x) (hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (M x) (F.map f) = M y) (X : CategoryTheory.WithInitial C)
Goal: (CategoryTheory.WithInitial.lift F M hM).obj X =
  match X with
  | CategoryTheory.WithInitial.of x => F.obj x
  | CategoryTheory.WithInitial.star => Z
-- CategoryTheory.WithInitial.inclLift_inv_app
@[simps!]
def inclLift {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (M : ∀ x : C, Z ⟶ F.obj x)
    (hM : ∀ (x y : C) (f : x ⟶ y), M x ≫ F.map f = M y) : incl ⋙ lift F M hM ≅ F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → Z ⟶ F.obj x) (hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (M x) (F.map f) = M y) (X : C)
Goal: (CategoryTheory.WithInitial.inclLift F M hM).inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.WithInitial.inclLift_hom_app
@[simps!]
def inclLift {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (M : ∀ x : C, Z ⟶ F.obj x)
    (hM : ∀ (x y : C) (f : x ⟶ y), M x ≫ F.map f = M y) : incl ⋙ lift F M hM ≅ F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → Z ⟶ F.obj x) (hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (M x) (F.map f) = M y) (X : C)
Goal: (CategoryTheory.WithInitial.inclLift F M hM).hom.app X =
  CategoryTheory.CategoryStruct.id
    (match CategoryTheory.WithInitial.incl.obj X with
    | CategoryTheory.WithInitial.of x => F.obj x
    | CategoryTheory.WithInitial.star => Z)
-- CategoryTheory.WithInitial.liftStar_inv
@[simps!]
def liftStar {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (M : ∀ x : C, Z ⟶ F.obj x)
    (hM : ∀ (x y : C) (f : x ⟶ y), M x ≫ F.map f = M y) : (lift F M hM).obj star ≅ Z 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → Z ⟶ F.obj x) (hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (M x) (F.map f) = M y)
Goal: (CategoryTheory.WithInitial.liftStar F M hM).inv = CategoryTheory.CategoryStruct.id Z
-- CategoryTheory.WithInitial.liftStar_hom
@[simps!]
def liftStar {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (M : ∀ x : C, Z ⟶ F.obj x)
    (hM : ∀ (x y : C) (f : x ⟶ y), M x ≫ F.map f = M y) : (lift F M hM).obj star ≅ Z 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → Z ⟶ F.obj x) (hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (M x) (F.map f) = M y)
Goal: (CategoryTheory.WithInitial.liftStar F M hM).hom = CategoryTheory.CategoryStruct.id Z
-- CategoryTheory.WithInitial.liftStar_lift_map
theorem liftStar_lift_map {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (M : ∀ x : C, Z ⟶ F.obj x)
    (hM : ∀ (x y : C) (f : x ⟶ y), M x ≫ F.map f = M y) (x : C) :
    (liftStar F M hM).hom ≫ (lift F M hM).map (starInitial.to (incl.obj x)) =
      M x ≫ (inclLift F M hM).hom.app x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → Z ⟶ F.obj x) (hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (M x) (F.map f) = M y) (x : C)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.WithInitial.liftStar F M hM).hom
    ((CategoryTheory.WithInitial.lift F M hM).map
      (CategoryTheory.WithInitial.starInitial.to (CategoryTheory.WithInitial.incl.obj x))) =
  CategoryTheory.CategoryStruct.comp (M x) ((CategoryTheory.WithInitial.inclLift F M hM).hom.app x)
-- CategoryTheory.WithInitial.liftToInitial_map
@[simps!]
def liftToInitial {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (hZ : Limits.IsInitial Z) :
    WithInitial C ⥤ D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (hZ : CategoryTheory.Limits.IsInitial Z) {X Y : CategoryTheory.WithInitial C} (f : X ⟶ Y)
Goal: (CategoryTheory.WithInitial.liftToInitial F hZ).map f =
  match X, Y, f with
  | CategoryTheory.WithInitial.of x, CategoryTheory.WithInitial.of y, f => F.map (CategoryTheory.WithInitial.down f)
  | CategoryTheory.WithInitial.star, CategoryTheory.WithInitial.of x, x_1 => hZ.to (F.obj x)
  | CategoryTheory.WithInitial.star, CategoryTheory.WithInitial.star, x => CategoryTheory.CategoryStruct.id Z
-- CategoryTheory.WithInitial.liftToInitial_obj
@[simps!]
def liftToInitial {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (hZ : Limits.IsInitial Z) :
    WithInitial C ⥤ D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (hZ : CategoryTheory.Limits.IsInitial Z) (X : CategoryTheory.WithInitial C)
Goal: (CategoryTheory.WithInitial.liftToInitial F hZ).obj X =
  match X with
  | CategoryTheory.WithInitial.of x => F.obj x
  | CategoryTheory.WithInitial.star => Z
-- CategoryTheory.WithInitial.inclLiftToInitial_hom_app
@[simps!]
def inclLiftToInitial {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (hZ : Limits.IsInitial Z) :
    incl ⋙ liftToInitial F hZ ≅ F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (hZ : CategoryTheory.Limits.IsInitial Z) (X : C)
Goal: (CategoryTheory.WithInitial.inclLiftToInitial F hZ).hom.app X =
  CategoryTheory.CategoryStruct.id
    (match CategoryTheory.WithInitial.incl.obj X with
    | CategoryTheory.WithInitial.of x => F.obj x
    | CategoryTheory.WithInitial.star => Z)
-- CategoryTheory.WithInitial.inclLiftToInitial_inv_app
@[simps!]
def inclLiftToInitial {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (hZ : Limits.IsInitial Z) :
    incl ⋙ liftToInitial F hZ ≅ F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (hZ : CategoryTheory.Limits.IsInitial Z) (X : C)
Goal: (CategoryTheory.WithInitial.inclLiftToInitial F hZ).inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.WithInitial.liftToInitialUnique_inv_app
@[simps!]
def liftToInitialUnique {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (hZ : Limits.IsInitial Z)
    (G : WithInitial C ⥤ D) (h : incl ⋙ G ≅ F) (hG : G.obj star ≅ Z) : G ≅ liftToInitial F hZ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (hZ : CategoryTheory.Limits.IsInitial Z) (G : CategoryTheory.Functor (CategoryTheory.WithInitial C) D) (h : CategoryTheory.WithInitial.incl.comp G ≅ F) (hG : G.obj CategoryTheory.WithInitial.star ≅ Z) (X : CategoryTheory.WithInitial C)
Goal: (CategoryTheory.WithInitial.liftToInitialUnique F hZ G h hG).inv.app X =
  (match X with
    | CategoryTheory.WithInitial.of x => h.app x
    | CategoryTheory.WithInitial.star => hG).inv
-- CategoryTheory.WithInitial.liftToInitialUnique_hom_app
@[simps!]
def liftToInitialUnique {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (hZ : Limits.IsInitial Z)
    (G : WithInitial C ⥤ D) (h : incl ⋙ G ≅ F) (hG : G.obj star ≅ Z) : G ≅ liftToInitial F hZ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {Z : D} (F : CategoryTheory.Functor C D) (hZ : CategoryTheory.Limits.IsInitial Z) (G : CategoryTheory.Functor (CategoryTheory.WithInitial C) D) (h : CategoryTheory.WithInitial.incl.comp G ≅ F) (hG : G.obj CategoryTheory.WithInitial.star ≅ Z) (X : CategoryTheory.WithInitial C)
Goal: (CategoryTheory.WithInitial.liftToInitialUnique F hZ G h hG).hom.app X =
  (match X with
    | CategoryTheory.WithInitial.of x => h.app x
    | CategoryTheory.WithInitial.star => hG).hom
-- CategoryTheory.LaxMonoidal.μ_natural_right
class LaxMonoidal (F : C → D) [Functorial.{v₁, v₂} F] where
    ε : 𝟙_ D ⟶ F (𝟙_ C)
    μ : ∀ X Y : C, F X ⊗ F Y ⟶ F (X ⊗ Y)
  μ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      map F f ▷ F X' ≫ μ Y X' = μ X X' ≫ map F (f ▷ X') := by
    aesop_cat
  μ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      F X' ◁ map F f ≫ μ X' Y = μ X' X ≫ map F (X' ◁ f) := by
    aesop_cat
    associativity :
    ∀ X Y Z : C,
      μ X Y ▷ F Z ≫ μ (X ⊗ Y) Z ≫ map F (α_ X Y Z).hom =
        (α_ (F X) (F Y) (F Z)).hom ≫ F X ◁ μ Y Z ≫ μ X (Y ⊗ Z) := by
    aesop_cat
    left_unitality : ∀ X : C, (λ_ (F X)).hom = ε ▷ F X ≫ μ (𝟙_ C) X ≫ map F (λ_ X).hom := by
    aesop_cat
    right_unitality : ∀ X : C, (ρ_ (F X)).hom = F X ◁ ε ≫ μ X (𝟙_ C) ≫ map F (ρ_ X).hom := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F : C → D} [CategoryTheory.Functorial F] [self : CategoryTheory.LaxMonoidal F] {X Y : C} (X' : C) (f : X ⟶ Y)
Goal: CategoryTheory.MonoidalCategory.whiskerLeft (F X') (CategoryTheory.map F f) ≫ CategoryTheory.LaxMonoidal.μ X' Y =
  CategoryTheory.LaxMonoidal.μ X' X ≫ CategoryTheory.map F (CategoryTheory.MonoidalCategory.whiskerLeft X' f)
-- CategoryTheory.LaxMonoidal.left_unitality
class LaxMonoidal (F : C → D) [Functorial.{v₁, v₂} F] where
    ε : 𝟙_ D ⟶ F (𝟙_ C)
    μ : ∀ X Y : C, F X ⊗ F Y ⟶ F (X ⊗ Y)
  μ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      map F f ▷ F X' ≫ μ Y X' = μ X X' ≫ map F (f ▷ X') := by
    aesop_cat
  μ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      F X' ◁ map F f ≫ μ X' Y = μ X' X ≫ map F (X' ◁ f) := by
    aesop_cat
    associativity :
    ∀ X Y Z : C,
      μ X Y ▷ F Z ≫ μ (X ⊗ Y) Z ≫ map F (α_ X Y Z).hom =
        (α_ (F X) (F Y) (F Z)).hom ≫ F X ◁ μ Y Z ≫ μ X (Y ⊗ Z) := by
    aesop_cat
    left_unitality : ∀ X : C, (λ_ (F X)).hom = ε ▷ F X ≫ μ (𝟙_ C) X ≫ map F (λ_ X).hom := by
    aesop_cat
    right_unitality : ∀ X : C, (ρ_ (F X)).hom = F X ◁ ε ≫ μ X (𝟙_ C) ≫ map F (ρ_ X).hom := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F : C → D} [CategoryTheory.Functorial F] [self : CategoryTheory.LaxMonoidal F] (X : C)
Goal: (CategoryTheory.MonoidalCategory.leftUnitor (F X)).hom =
  CategoryTheory.MonoidalCategory.whiskerRight CategoryTheory.LaxMonoidal.ε (F X) ≫
    CategoryTheory.LaxMonoidal.μ (𝟙_ C) X ≫ CategoryTheory.map F (CategoryTheory.MonoidalCategory.leftUnitor X).hom
-- CategoryTheory.LaxMonoidal.associativity
class LaxMonoidal (F : C → D) [Functorial.{v₁, v₂} F] where
    ε : 𝟙_ D ⟶ F (𝟙_ C)
    μ : ∀ X Y : C, F X ⊗ F Y ⟶ F (X ⊗ Y)
  μ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      map F f ▷ F X' ≫ μ Y X' = μ X X' ≫ map F (f ▷ X') := by
    aesop_cat
  μ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      F X' ◁ map F f ≫ μ X' Y = μ X' X ≫ map F (X' ◁ f) := by
    aesop_cat
    associativity :
    ∀ X Y Z : C,
      μ X Y ▷ F Z ≫ μ (X ⊗ Y) Z ≫ map F (α_ X Y Z).hom =
        (α_ (F X) (F Y) (F Z)).hom ≫ F X ◁ μ Y Z ≫ μ X (Y ⊗ Z) := by
    aesop_cat
    left_unitality : ∀ X : C, (λ_ (F X)).hom = ε ▷ F X ≫ μ (𝟙_ C) X ≫ map F (λ_ X).hom := by
    aesop_cat
    right_unitality : ∀ X : C, (ρ_ (F X)).hom = F X ◁ ε ≫ μ X (𝟙_ C) ≫ map F (ρ_ X).hom := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F : C → D} [CategoryTheory.Functorial F] [self : CategoryTheory.LaxMonoidal F] (X Y Z : C)
Goal: CategoryTheory.MonoidalCategory.whiskerRight (CategoryTheory.LaxMonoidal.μ X Y) (F Z) ≫
    CategoryTheory.LaxMonoidal.μ (CategoryTheory.MonoidalCategory.tensorObj X Y) Z ≫
      CategoryTheory.map F (CategoryTheory.MonoidalCategory.associator X Y Z).hom =
  (CategoryTheory.MonoidalCategory.associator (F X) (F Y) (F Z)).hom ≫
    CategoryTheory.MonoidalCategory.whiskerLeft (F X) (CategoryTheory.LaxMonoidal.μ Y Z) ≫
      CategoryTheory.LaxMonoidal.μ X (CategoryTheory.MonoidalCategory.tensorObj Y Z)
-- CategoryTheory.LaxMonoidal.right_unitality
class LaxMonoidal (F : C → D) [Functorial.{v₁, v₂} F] where
    ε : 𝟙_ D ⟶ F (𝟙_ C)
    μ : ∀ X Y : C, F X ⊗ F Y ⟶ F (X ⊗ Y)
  μ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      map F f ▷ F X' ≫ μ Y X' = μ X X' ≫ map F (f ▷ X') := by
    aesop_cat
  μ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      F X' ◁ map F f ≫ μ X' Y = μ X' X ≫ map F (X' ◁ f) := by
    aesop_cat
    associativity :
    ∀ X Y Z : C,
      μ X Y ▷ F Z ≫ μ (X ⊗ Y) Z ≫ map F (α_ X Y Z).hom =
        (α_ (F X) (F Y) (F Z)).hom ≫ F X ◁ μ Y Z ≫ μ X (Y ⊗ Z) := by
    aesop_cat
    left_unitality : ∀ X : C, (λ_ (F X)).hom = ε ▷ F X ≫ μ (𝟙_ C) X ≫ map F (λ_ X).hom := by
    aesop_cat
    right_unitality : ∀ X : C, (ρ_ (F X)).hom = F X ◁ ε ≫ μ X (𝟙_ C) ≫ map F (ρ_ X).hom := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F : C → D} [CategoryTheory.Functorial F] [self : CategoryTheory.LaxMonoidal F] (X : C)
Goal: (CategoryTheory.MonoidalCategory.rightUnitor (F X)).hom =
  CategoryTheory.MonoidalCategory.whiskerLeft (F X) CategoryTheory.LaxMonoidal.ε ≫
    CategoryTheory.LaxMonoidal.μ X (𝟙_ C) ≫ CategoryTheory.map F (CategoryTheory.MonoidalCategory.rightUnitor X).hom
-- CategoryTheory.LaxMonoidal.μ_natural_left
class LaxMonoidal (F : C → D) [Functorial.{v₁, v₂} F] where
    ε : 𝟙_ D ⟶ F (𝟙_ C)
    μ : ∀ X Y : C, F X ⊗ F Y ⟶ F (X ⊗ Y)
  μ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      map F f ▷ F X' ≫ μ Y X' = μ X X' ≫ map F (f ▷ X') := by
    aesop_cat
  μ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      F X' ◁ map F f ≫ μ X' Y = μ X' X ≫ map F (X' ◁ f) := by
    aesop_cat
    associativity :
    ∀ X Y Z : C,
      μ X Y ▷ F Z ≫ μ (X ⊗ Y) Z ≫ map F (α_ X Y Z).hom =
        (α_ (F X) (F Y) (F Z)).hom ≫ F X ◁ μ Y Z ≫ μ X (Y ⊗ Z) := by
    aesop_cat
    left_unitality : ∀ X : C, (λ_ (F X)).hom = ε ▷ F X ≫ μ (𝟙_ C) X ≫ map F (λ_ X).hom := by
    aesop_cat
    right_unitality : ∀ X : C, (ρ_ (F X)).hom = F X ◁ ε ≫ μ X (𝟙_ C) ≫ map F (ρ_ X).hom := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F : C → D} [CategoryTheory.Functorial F] [self : CategoryTheory.LaxMonoidal F] {X Y : C} (f : X ⟶ Y) (X' : C)
Goal: CategoryTheory.MonoidalCategory.whiskerRight (CategoryTheory.map F f) (F X') ≫ CategoryTheory.LaxMonoidal.μ Y X' =
  CategoryTheory.LaxMonoidal.μ X X' ≫ CategoryTheory.map F (CategoryTheory.MonoidalCategory.whiskerRight f X')
-- CategoryTheory.LaxMonoidalFunctor.of_μ
@[simps]
def of (F : C → D) [I₁ : Functorial.{v₁, v₂} F] [I₂ : LaxMonoidal.{v₁, v₂} F] :
    LaxMonoidalFunctor.{v₁, v₂} C D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (F : C → D) [I₁ : CategoryTheory.Functorial F] [I₂ : CategoryTheory.LaxMonoidal F] (X Y : C)
Goal: (CategoryTheory.LaxMonoidalFunctor.of F).μ X Y = CategoryTheory.LaxMonoidal.μ X Y
-- CategoryTheory.LaxMonoidalFunctor.of_ε
@[simps]
def of (F : C → D) [I₁ : Functorial.{v₁, v₂} F] [I₂ : LaxMonoidal.{v₁, v₂} F] :
    LaxMonoidalFunctor.{v₁, v₂} C D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (F : C → D) [I₁ : CategoryTheory.Functorial F] [I₂ : CategoryTheory.LaxMonoidal F]
Goal: (CategoryTheory.LaxMonoidalFunctor.of F).ε = CategoryTheory.LaxMonoidal.ε
-- CategoryTheory.LaxMonoidalFunctor.of_toFunctor_obj
@[simps]
def of (F : C → D) [I₁ : Functorial.{v₁, v₂} F] [I₂ : LaxMonoidal.{v₁, v₂} F] :
    LaxMonoidalFunctor.{v₁, v₂} C D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (F : C → D) [I₁ : CategoryTheory.Functorial F] [I₂ : CategoryTheory.LaxMonoidal F]
Goal: ∀ (a : C), (CategoryTheory.LaxMonoidalFunctor.of F).obj a = F a
-- CategoryTheory.LaxMonoidalFunctor.of_toFunctor_map
@[simps]
def of (F : C → D) [I₁ : Functorial.{v₁, v₂} F] [I₂ : LaxMonoidal.{v₁, v₂} F] :
    LaxMonoidalFunctor.{v₁, v₂} C D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (F : C → D) [I₁ : CategoryTheory.Functorial F] [I₂ : CategoryTheory.LaxMonoidal F] {X Y : C}
Goal: ∀ (a : X ⟶ Y), (CategoryTheory.LaxMonoidalFunctor.of F).map a = CategoryTheory.Functorial.map' a