File: Mathlib/CategoryTheory/Monoidal/Functor.lean

full_name: CategoryTheory.LaxMonoidalFunctor.μ
code: /-- A lax monoidal functor is a functor `F : C ⥤ D` between monoidal categories,
equipped with morphisms `ε : 𝟙 _D ⟶ F.obj (𝟙_ C)` and `μ X Y : F.obj X ⊗ F.obj Y ⟶ F.obj (X ⊗ Y)`,
satisfying the appropriate coherences. -/
structure LaxMonoidalFunctor extends C ⥤ D where
  /-- unit morphism -/
  ε : 𝟙_ D ⟶ obj (𝟙_ C)
  /-- tensorator -/
  μ : ∀ X Y : C, obj X ⊗ obj Y ⟶ obj (X ⊗ Y)
  μ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      map f ▷ obj X' ≫ μ Y X' = μ X X' ≫ map (f ▷ X') := by
    aesop_cat
  μ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      obj X' ◁ map f ≫ μ X' Y = μ X' X ≫ map (X' ◁ f) := by
    aesop_cat
  /-- associativity of the tensorator -/
  associativity :
    ∀ X Y Z : C,
      μ X Y ▷ obj Z ≫ μ (X ⊗ Y) Z ≫ map (α_ X Y Z).hom =
        (α_ (obj X) (obj Y) (obj Z)).hom ≫ obj X ◁ μ Y Z ≫ μ X (Y ⊗ Z) := by
    aesop_cat
  -- unitality
  left_unitality : ∀ X : C, (λ_ (obj X)).hom = ε ▷ obj X ≫ μ (𝟙_ C) X ≫ map (λ_ X).hom := by
    aesop_cat
  right_unitality : ∀ X : C, (ρ_ (obj X)).hom = obj X ◁ ε ≫ μ X (𝟙_ C) ≫ map (ρ_ X).hom := by
    aesop_cat
goal: CategoryTheory.MonoidalCategory.tensorObj (self.obj X) (self.obj Y) ⟶
  self.obj (CategoryTheory.MonoidalCategory.tensorObj X Y)

full_name: CategoryTheory.LaxMonoidalFunctor.right_unitality
code: /-- A lax monoidal functor is a functor `F : C ⥤ D` between monoidal categories,
equipped with morphisms `ε : 𝟙 _D ⟶ F.obj (𝟙_ C)` and `μ X Y : F.obj X ⊗ F.obj Y ⟶ F.obj (X ⊗ Y)`,
satisfying the appropriate coherences. -/
structure LaxMonoidalFunctor extends C ⥤ D where
  /-- unit morphism -/
  ε : 𝟙_ D ⟶ obj (𝟙_ C)
  /-- tensorator -/
  μ : ∀ X Y : C, obj X ⊗ obj Y ⟶ obj (X ⊗ Y)
  μ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      map f ▷ obj X' ≫ μ Y X' = μ X X' ≫ map (f ▷ X') := by
    aesop_cat
  μ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      obj X' ◁ map f ≫ μ X' Y = μ X' X ≫ map (X' ◁ f) := by
    aesop_cat
  /-- associativity of the tensorator -/
  associativity :
    ∀ X Y Z : C,
      μ X Y ▷ obj Z ≫ μ (X ⊗ Y) Z ≫ map (α_ X Y Z).hom =
        (α_ (obj X) (obj Y) (obj Z)).hom ≫ obj X ◁ μ Y Z ≫ μ X (Y ⊗ Z) := by
    aesop_cat
  -- unitality
  left_unitality : ∀ X : C, (λ_ (obj X)).hom = ε ▷ obj X ≫ μ (𝟙_ C) X ≫ map (λ_ X).hom := by
    aesop_cat
  right_unitality : ∀ X : C, (ρ_ (obj X)).hom = obj X ◁ ε ≫ μ X (𝟙_ C) ≫ map (ρ_ X).hom := by
    aesop_cat
goal: (CategoryTheory.MonoidalCategory.rightUnitor (self.obj X)).hom =
  CategoryTheory.MonoidalCategory.whiskerLeft (self.obj X) self.ε ≫
    self.μ X (𝟙_ C) ≫ self.map (CategoryTheory.MonoidalCategory.rightUnitor X).hom

full_name: CategoryTheory.LaxMonoidalFunctor
code: /-- A lax monoidal functor is a functor `F : C ⥤ D` between monoidal categories,
equipped with morphisms `ε : 𝟙 _D ⟶ F.obj (𝟙_ C)` and `μ X Y : F.obj X ⊗ F.obj Y ⟶ F.obj (X ⊗ Y)`,
satisfying the appropriate coherences. -/
structure LaxMonoidalFunctor extends C ⥤ D where
  /-- unit morphism -/
  ε : 𝟙_ D ⟶ obj (𝟙_ C)
  /-- tensorator -/
  μ : ∀ X Y : C, obj X ⊗ obj Y ⟶ obj (X ⊗ Y)
  μ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      map f ▷ obj X' ≫ μ Y X' = μ X X' ≫ map (f ▷ X') := by
    aesop_cat
  μ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      obj X' ◁ map f ≫ μ X' Y = μ X' X ≫ map (X' ◁ f) := by
    aesop_cat
  /-- associativity of the tensorator -/
  associativity :
    ∀ X Y Z : C,
      μ X Y ▷ obj Z ≫ μ (X ⊗ Y) Z ≫ map (α_ X Y Z).hom =
        (α_ (obj X) (obj Y) (obj Z)).hom ≫ obj X ◁ μ Y Z ≫ μ X (Y ⊗ Z) := by
    aesop_cat
  -- unitality
  left_unitality : ∀ X : C, (λ_ (obj X)).hom = ε ▷ obj X ≫ μ (𝟙_ C) X ≫ map (λ_ X).hom := by
    aesop_cat
  right_unitality : ∀ X : C, (ρ_ (obj X)).hom = obj X ◁ ε ≫ μ X (𝟙_ C) ≫ map (ρ_ X).hom := by
    aesop_cat
goal: Type (max (max (max u₁ u₂) v₁) v₂)

full_name: CategoryTheory.LaxMonoidalFunctor.μ_natural_right
code: /-- A lax monoidal functor is a functor `F : C ⥤ D` between monoidal categories,
equipped with morphisms `ε : 𝟙 _D ⟶ F.obj (𝟙_ C)` and `μ X Y : F.obj X ⊗ F.obj Y ⟶ F.obj (X ⊗ Y)`,
satisfying the appropriate coherences. -/
structure LaxMonoidalFunctor extends C ⥤ D where
  /-- unit morphism -/
  ε : 𝟙_ D ⟶ obj (𝟙_ C)
  /-- tensorator -/
  μ : ∀ X Y : C, obj X ⊗ obj Y ⟶ obj (X ⊗ Y)
  μ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      map f ▷ obj X' ≫ μ Y X' = μ X X' ≫ map (f ▷ X') := by
    aesop_cat
  μ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      obj X' ◁ map f ≫ μ X' Y = μ X' X ≫ map (X' ◁ f) := by
    aesop_cat
  /-- associativity of the tensorator -/
  associativity :
    ∀ X Y Z : C,
      μ X Y ▷ obj Z ≫ μ (X ⊗ Y) Z ≫ map (α_ X Y Z).hom =
        (α_ (obj X) (obj Y) (obj Z)).hom ≫ obj X ◁ μ Y Z ≫ μ X (Y ⊗ Z) := by
    aesop_cat
  -- unitality
  left_unitality : ∀ X : C, (λ_ (obj X)).hom = ε ▷ obj X ≫ μ (𝟙_ C) X ≫ map (λ_ X).hom := by
    aesop_cat
  right_unitality : ∀ X : C, (ρ_ (obj X)).hom = obj X ◁ ε ≫ μ X (𝟙_ C) ≫ map (ρ_ X).hom := by
    aesop_cat
goal: CategoryTheory.MonoidalCategory.whiskerLeft (self.obj X') (self.map f) ≫ self.μ X' Y =
  self.μ X' X ≫ self.map (CategoryTheory.MonoidalCategory.whiskerLeft X' f)

full_name: CategoryTheory.LaxMonoidalFunctor.associativity
code: /-- A lax monoidal functor is a functor `F : C ⥤ D` between monoidal categories,
equipped with morphisms `ε : 𝟙 _D ⟶ F.obj (𝟙_ C)` and `μ X Y : F.obj X ⊗ F.obj Y ⟶ F.obj (X ⊗ Y)`,
satisfying the appropriate coherences. -/
structure LaxMonoidalFunctor extends C ⥤ D where
  /-- unit morphism -/
  ε : 𝟙_ D ⟶ obj (𝟙_ C)
  /-- tensorator -/
  μ : ∀ X Y : C, obj X ⊗ obj Y ⟶ obj (X ⊗ Y)
  μ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      map f ▷ obj X' ≫ μ Y X' = μ X X' ≫ map (f ▷ X') := by
    aesop_cat
  μ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      obj X' ◁ map f ≫ μ X' Y = μ X' X ≫ map (X' ◁ f) := by
    aesop_cat
  /-- associativity of the tensorator -/
  associativity :
    ∀ X Y Z : C,
      μ X Y ▷ obj Z ≫ μ (X ⊗ Y) Z ≫ map (α_ X Y Z).hom =
        (α_ (obj X) (obj Y) (obj Z)).hom ≫ obj X ◁ μ Y Z ≫ μ X (Y ⊗ Z) := by
    aesop_cat
  -- unitality
  left_unitality : ∀ X : C, (λ_ (obj X)).hom = ε ▷ obj X ≫ μ (𝟙_ C) X ≫ map (λ_ X).hom := by
    aesop_cat
  right_unitality : ∀ X : C, (ρ_ (obj X)).hom = obj X ◁ ε ≫ μ X (𝟙_ C) ≫ map (ρ_ X).hom := by
    aesop_cat
goal: CategoryTheory.MonoidalCategory.whiskerRight (self.μ X Y) (self.obj Z) ≫
    self.μ (CategoryTheory.MonoidalCategory.tensorObj X Y) Z ≫
      self.map (CategoryTheory.MonoidalCategory.associator X Y Z).hom =
  (CategoryTheory.MonoidalCategory.associator (self.obj X) (self.obj Y) (self.obj Z)).hom ≫
    CategoryTheory.MonoidalCategory.whiskerLeft (self.obj X) (self.μ Y Z) ≫
      self.μ X (CategoryTheory.MonoidalCategory.tensorObj Y Z)

full_name: CategoryTheory.LaxMonoidalFunctor.ε
code: /-- A lax monoidal functor is a functor `F : C ⥤ D` between monoidal categories,
equipped with morphisms `ε : 𝟙 _D ⟶ F.obj (𝟙_ C)` and `μ X Y : F.obj X ⊗ F.obj Y ⟶ F.obj (X ⊗ Y)`,
satisfying the appropriate coherences. -/
structure LaxMonoidalFunctor extends C ⥤ D where
  /-- unit morphism -/
  ε : 𝟙_ D ⟶ obj (𝟙_ C)
  /-- tensorator -/
  μ : ∀ X Y : C, obj X ⊗ obj Y ⟶ obj (X ⊗ Y)
  μ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      map f ▷ obj X' ≫ μ Y X' = μ X X' ≫ map (f ▷ X') := by
    aesop_cat
  μ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      obj X' ◁ map f ≫ μ X' Y = μ X' X ≫ map (X' ◁ f) := by
    aesop_cat
  /-- associativity of the tensorator -/
  associativity :
    ∀ X Y Z : C,
      μ X Y ▷ obj Z ≫ μ (X ⊗ Y) Z ≫ map (α_ X Y Z).hom =
        (α_ (obj X) (obj Y) (obj Z)).hom ≫ obj X ◁ μ Y Z ≫ μ X (Y ⊗ Z) := by
    aesop_cat
  -- unitality
  left_unitality : ∀ X : C, (λ_ (obj X)).hom = ε ▷ obj X ≫ μ (𝟙_ C) X ≫ map (λ_ X).hom := by
    aesop_cat
  right_unitality : ∀ X : C, (ρ_ (obj X)).hom = obj X ◁ ε ≫ μ X (𝟙_ C) ≫ map (ρ_ X).hom := by
    aesop_cat
goal: 𝟙_ D ⟶ self.obj (𝟙_ C)

full_name: CategoryTheory.LaxMonoidalFunctor.left_unitality
code: /-- A lax monoidal functor is a functor `F : C ⥤ D` between monoidal categories,
equipped with morphisms `ε : 𝟙 _D ⟶ F.obj (𝟙_ C)` and `μ X Y : F.obj X ⊗ F.obj Y ⟶ F.obj (X ⊗ Y)`,
satisfying the appropriate coherences. -/
structure LaxMonoidalFunctor extends C ⥤ D where
  /-- unit morphism -/
  ε : 𝟙_ D ⟶ obj (𝟙_ C)
  /-- tensorator -/
  μ : ∀ X Y : C, obj X ⊗ obj Y ⟶ obj (X ⊗ Y)
  μ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      map f ▷ obj X' ≫ μ Y X' = μ X X' ≫ map (f ▷ X') := by
    aesop_cat
  μ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      obj X' ◁ map f ≫ μ X' Y = μ X' X ≫ map (X' ◁ f) := by
    aesop_cat
  /-- associativity of the tensorator -/
  associativity :
    ∀ X Y Z : C,
      μ X Y ▷ obj Z ≫ μ (X ⊗ Y) Z ≫ map (α_ X Y Z).hom =
        (α_ (obj X) (obj Y) (obj Z)).hom ≫ obj X ◁ μ Y Z ≫ μ X (Y ⊗ Z) := by
    aesop_cat
  -- unitality
  left_unitality : ∀ X : C, (λ_ (obj X)).hom = ε ▷ obj X ≫ μ (𝟙_ C) X ≫ map (λ_ X).hom := by
    aesop_cat
  right_unitality : ∀ X : C, (ρ_ (obj X)).hom = obj X ◁ ε ≫ μ X (𝟙_ C) ≫ map (ρ_ X).hom := by
    aesop_cat
goal: (CategoryTheory.MonoidalCategory.leftUnitor (self.obj X)).hom =
  CategoryTheory.MonoidalCategory.whiskerRight self.ε (self.obj X) ≫
    self.μ (𝟙_ C) X ≫ self.map (CategoryTheory.MonoidalCategory.leftUnitor X).hom

full_name: CategoryTheory.LaxMonoidalFunctor.μ_natural_left
code: /-- A lax monoidal functor is a functor `F : C ⥤ D` between monoidal categories,
equipped with morphisms `ε : 𝟙 _D ⟶ F.obj (𝟙_ C)` and `μ X Y : F.obj X ⊗ F.obj Y ⟶ F.obj (X ⊗ Y)`,
satisfying the appropriate coherences. -/
structure LaxMonoidalFunctor extends C ⥤ D where
  /-- unit morphism -/
  ε : 𝟙_ D ⟶ obj (𝟙_ C)
  /-- tensorator -/
  μ : ∀ X Y : C, obj X ⊗ obj Y ⟶ obj (X ⊗ Y)
  μ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      map f ▷ obj X' ≫ μ Y X' = μ X X' ≫ map (f ▷ X') := by
    aesop_cat
  μ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      obj X' ◁ map f ≫ μ X' Y = μ X' X ≫ map (X' ◁ f) := by
    aesop_cat
  /-- associativity of the tensorator -/
  associativity :
    ∀ X Y Z : C,
      μ X Y ▷ obj Z ≫ μ (X ⊗ Y) Z ≫ map (α_ X Y Z).hom =
        (α_ (obj X) (obj Y) (obj Z)).hom ≫ obj X ◁ μ Y Z ≫ μ X (Y ⊗ Z) := by
    aesop_cat
  -- unitality
  left_unitality : ∀ X : C, (λ_ (obj X)).hom = ε ▷ obj X ≫ μ (𝟙_ C) X ≫ map (λ_ X).hom := by
    aesop_cat
  right_unitality : ∀ X : C, (ρ_ (obj X)).hom = obj X ◁ ε ≫ μ X (𝟙_ C) ≫ map (ρ_ X).hom := by
    aesop_cat
goal: CategoryTheory.MonoidalCategory.whiskerRight (self.map f) (self.obj X') ≫ self.μ Y X' =
  self.μ X X' ≫ self.map (CategoryTheory.MonoidalCategory.whiskerRight f X')

full_name: CategoryTheory.LaxMonoidalFunctor.μ_natural
code: @[reassoc (attr := simp)]
theorem LaxMonoidalFunctor.μ_natural (F : LaxMonoidalFunctor C D) {X Y X' Y' : C}
    (f : X ⟶ Y) (g : X' ⟶ Y') :
      (F.map f ⊗ F.map g) ≫ F.μ Y Y' = F.μ X X' ≫ F.map (f ⊗ g) 
goal: CategoryTheory.MonoidalCategory.tensorHom (F.map f) (F.map g) ≫ F.μ Y Y' =
  F.μ X X' ≫ F.map (CategoryTheory.MonoidalCategory.tensorHom f g)

full_name: CategoryTheory.LaxMonoidalFunctor.ofTensorHom_μ
code: /--
A constructor for lax monoidal functors whose axioms are described by `tensorHom` instead of
`whiskerLeft` and `whiskerRight`.
-/
@[simps]
def LaxMonoidalFunctor.ofTensorHom (F : C ⥤ D)
    /- unit morphism -/
    (ε : 𝟙_ D ⟶ F.obj (𝟙_ C))
    /- tensorator -/
    (μ : ∀ X Y : C, F.obj X ⊗ F.obj Y ⟶ F.obj (X ⊗ Y))
    (μ_natural :
      ∀ {X Y X' Y' : C} (f : X ⟶ Y) (g : X' ⟶ Y'),
        (F.map f ⊗ F.map g) ≫ μ Y Y' = μ X X' ≫ F.map (f ⊗ g) := by
      aesop_cat)
    /- associativity of the tensorator -/
    (associativity :
      ∀ X Y Z : C,
        (μ X Y ⊗ 𝟙 (F.obj Z)) ≫ μ (X ⊗ Y) Z ≫ F.map (α_ X Y Z).hom =
          (α_ (F.obj X) (F.obj Y) (F.obj Z)).hom ≫ (𝟙 (F.obj X) ⊗ μ Y Z) ≫ μ X (Y ⊗ Z) := by
      aesop_cat)
    /- unitality -/
    (left_unitality :
      ∀ X : C, (λ_ (F.obj X)).hom = (ε ⊗ 𝟙 (F.obj X)) ≫ μ (𝟙_ C) X ≫ F.map (λ_ X).hom := by
        aesop_cat)
    (right_unitality :
      ∀ X : C, (ρ_ (F.obj X)).hom = (𝟙 (F.obj X) ⊗ ε) ≫ μ X (𝟙_ C) ≫ F.map (ρ_ X).hom := by
        aesop_cat) :
        LaxMonoidalFunctor C D 
goal: (CategoryTheory.LaxMonoidalFunctor.ofTensorHom F ε μ μ_natural associativity left_unitality right_unitality).μ X Y =
  μ X Y

full_name: CategoryTheory.LaxMonoidalFunctor.ofTensorHom_toFunctor_map
code: /--
A constructor for lax monoidal functors whose axioms are described by `tensorHom` instead of
`whiskerLeft` and `whiskerRight`.
-/
@[simps]
def LaxMonoidalFunctor.ofTensorHom (F : C ⥤ D)
    /- unit morphism -/
    (ε : 𝟙_ D ⟶ F.obj (𝟙_ C))
    /- tensorator -/
    (μ : ∀ X Y : C, F.obj X ⊗ F.obj Y ⟶ F.obj (X ⊗ Y))
    (μ_natural :
      ∀ {X Y X' Y' : C} (f : X ⟶ Y) (g : X' ⟶ Y'),
        (F.map f ⊗ F.map g) ≫ μ Y Y' = μ X X' ≫ F.map (f ⊗ g) := by
      aesop_cat)
    /- associativity of the tensorator -/
    (associativity :
      ∀ X Y Z : C,
        (μ X Y ⊗ 𝟙 (F.obj Z)) ≫ μ (X ⊗ Y) Z ≫ F.map (α_ X Y Z).hom =
          (α_ (F.obj X) (F.obj Y) (F.obj Z)).hom ≫ (𝟙 (F.obj X) ⊗ μ Y Z) ≫ μ X (Y ⊗ Z) := by
      aesop_cat)
    /- unitality -/
    (left_unitality :
      ∀ X : C, (λ_ (F.obj X)).hom = (ε ⊗ 𝟙 (F.obj X)) ≫ μ (𝟙_ C) X ≫ F.map (λ_ X).hom := by
        aesop_cat)
    (right_unitality :
      ∀ X : C, (ρ_ (F.obj X)).hom = (𝟙 (F.obj X) ⊗ ε) ≫ μ X (𝟙_ C) ≫ F.map (ρ_ X).hom := by
        aesop_cat) :
        LaxMonoidalFunctor C D 
goal: ∀ {X Y : C} (a : X ⟶ Y),
  (CategoryTheory.LaxMonoidalFunctor.ofTensorHom F ε μ μ_natural associativity left_unitality right_unitality).map a =
    F.map a

full_name: CategoryTheory.LaxMonoidalFunctor.ofTensorHom_ε
code: /--
A constructor for lax monoidal functors whose axioms are described by `tensorHom` instead of
`whiskerLeft` and `whiskerRight`.
-/
@[simps]
def LaxMonoidalFunctor.ofTensorHom (F : C ⥤ D)
    /- unit morphism -/
    (ε : 𝟙_ D ⟶ F.obj (𝟙_ C))
    /- tensorator -/
    (μ : ∀ X Y : C, F.obj X ⊗ F.obj Y ⟶ F.obj (X ⊗ Y))
    (μ_natural :
      ∀ {X Y X' Y' : C} (f : X ⟶ Y) (g : X' ⟶ Y'),
        (F.map f ⊗ F.map g) ≫ μ Y Y' = μ X X' ≫ F.map (f ⊗ g) := by
      aesop_cat)
    /- associativity of the tensorator -/
    (associativity :
      ∀ X Y Z : C,
        (μ X Y ⊗ 𝟙 (F.obj Z)) ≫ μ (X ⊗ Y) Z ≫ F.map (α_ X Y Z).hom =
          (α_ (F.obj X) (F.obj Y) (F.obj Z)).hom ≫ (𝟙 (F.obj X) ⊗ μ Y Z) ≫ μ X (Y ⊗ Z) := by
      aesop_cat)
    /- unitality -/
    (left_unitality :
      ∀ X : C, (λ_ (F.obj X)).hom = (ε ⊗ 𝟙 (F.obj X)) ≫ μ (𝟙_ C) X ≫ F.map (λ_ X).hom := by
        aesop_cat)
    (right_unitality :
      ∀ X : C, (ρ_ (F.obj X)).hom = (𝟙 (F.obj X) ⊗ ε) ≫ μ X (𝟙_ C) ≫ F.map (ρ_ X).hom := by
        aesop_cat) :
        LaxMonoidalFunctor C D 
goal: (CategoryTheory.LaxMonoidalFunctor.ofTensorHom F ε μ μ_natural associativity left_unitality right_unitality).ε = ε

full_name: CategoryTheory.LaxMonoidalFunctor.ofTensorHom
code: /--
A constructor for lax monoidal functors whose axioms are described by `tensorHom` instead of
`whiskerLeft` and `whiskerRight`.
-/
@[simps]
def LaxMonoidalFunctor.ofTensorHom (F : C ⥤ D)
    /- unit morphism -/
    (ε : 𝟙_ D ⟶ F.obj (𝟙_ C))
    /- tensorator -/
    (μ : ∀ X Y : C, F.obj X ⊗ F.obj Y ⟶ F.obj (X ⊗ Y))
    (μ_natural :
      ∀ {X Y X' Y' : C} (f : X ⟶ Y) (g : X' ⟶ Y'),
        (F.map f ⊗ F.map g) ≫ μ Y Y' = μ X X' ≫ F.map (f ⊗ g) := by
      aesop_cat)
    /- associativity of the tensorator -/
    (associativity :
      ∀ X Y Z : C,
        (μ X Y ⊗ 𝟙 (F.obj Z)) ≫ μ (X ⊗ Y) Z ≫ F.map (α_ X Y Z).hom =
          (α_ (F.obj X) (F.obj Y) (F.obj Z)).hom ≫ (𝟙 (F.obj X) ⊗ μ Y Z) ≫ μ X (Y ⊗ Z) := by
      aesop_cat)
    /- unitality -/
    (left_unitality :
      ∀ X : C, (λ_ (F.obj X)).hom = (ε ⊗ 𝟙 (F.obj X)) ≫ μ (𝟙_ C) X ≫ F.map (λ_ X).hom := by
        aesop_cat)
    (right_unitality :
      ∀ X : C, (ρ_ (F.obj X)).hom = (𝟙 (F.obj X) ⊗ ε) ≫ μ X (𝟙_ C) ≫ F.map (ρ_ X).hom := by
        aesop_cat) :
        LaxMonoidalFunctor C D 
goal: CategoryTheory.LaxMonoidalFunctor C D

full_name: CategoryTheory.LaxMonoidalFunctor.ofTensorHom_toFunctor_obj
code: /--
A constructor for lax monoidal functors whose axioms are described by `tensorHom` instead of
`whiskerLeft` and `whiskerRight`.
-/
@[simps]
def LaxMonoidalFunctor.ofTensorHom (F : C ⥤ D)
    /- unit morphism -/
    (ε : 𝟙_ D ⟶ F.obj (𝟙_ C))
    /- tensorator -/
    (μ : ∀ X Y : C, F.obj X ⊗ F.obj Y ⟶ F.obj (X ⊗ Y))
    (μ_natural :
      ∀ {X Y X' Y' : C} (f : X ⟶ Y) (g : X' ⟶ Y'),
        (F.map f ⊗ F.map g) ≫ μ Y Y' = μ X X' ≫ F.map (f ⊗ g) := by
      aesop_cat)
    /- associativity of the tensorator -/
    (associativity :
      ∀ X Y Z : C,
        (μ X Y ⊗ 𝟙 (F.obj Z)) ≫ μ (X ⊗ Y) Z ≫ F.map (α_ X Y Z).hom =
          (α_ (F.obj X) (F.obj Y) (F.obj Z)).hom ≫ (𝟙 (F.obj X) ⊗ μ Y Z) ≫ μ X (Y ⊗ Z) := by
      aesop_cat)
    /- unitality -/
    (left_unitality :
      ∀ X : C, (λ_ (F.obj X)).hom = (ε ⊗ 𝟙 (F.obj X)) ≫ μ (𝟙_ C) X ≫ F.map (λ_ X).hom := by
        aesop_cat)
    (right_unitality :
      ∀ X : C, (ρ_ (F.obj X)).hom = (𝟙 (F.obj X) ⊗ ε) ≫ μ X (𝟙_ C) ≫ F.map (ρ_ X).hom := by
        aesop_cat) :
        LaxMonoidalFunctor C D 
goal: ∀ (a : C),
  (CategoryTheory.LaxMonoidalFunctor.ofTensorHom F ε μ μ_natural associativity left_unitality right_unitality).obj a =
    F.obj a

full_name: CategoryTheory.LaxMonoidalFunctor.left_unitality_inv
code: @[reassoc (attr := simp)]
theorem LaxMonoidalFunctor.left_unitality_inv (F : LaxMonoidalFunctor C D) (X : C) :
    (λ_ (F.obj X)).inv ≫ F.ε ▷ F.obj X ≫ F.μ (𝟙_ C) X = F.map (λ_ X).inv 
goal: (CategoryTheory.MonoidalCategory.leftUnitor (F.obj X)).inv ≫
    CategoryTheory.MonoidalCategory.whiskerRight F.ε (F.obj X) ≫ F.μ (𝟙_ C) X =
  F.map (CategoryTheory.MonoidalCategory.leftUnitor X).inv

full_name: CategoryTheory.LaxMonoidalFunctor.right_unitality_inv
code: @[reassoc (attr := simp)]
theorem LaxMonoidalFunctor.right_unitality_inv (F : LaxMonoidalFunctor C D) (X : C) :
    (ρ_ (F.obj X)).inv ≫ F.obj X ◁ F.ε ≫ F.μ X (𝟙_ C) = F.map (ρ_ X).inv 
goal: (CategoryTheory.MonoidalCategory.rightUnitor (F.obj X)).inv ≫
    CategoryTheory.MonoidalCategory.whiskerLeft (F.obj X) F.ε ≫ F.μ X (𝟙_ C) =
  F.map (CategoryTheory.MonoidalCategory.rightUnitor X).inv

full_name: CategoryTheory.LaxMonoidalFunctor.associativity_inv
code: @[reassoc (attr := simp)]
theorem LaxMonoidalFunctor.associativity_inv (F : LaxMonoidalFunctor C D) (X Y Z : C) :
    F.obj X ◁ F.μ Y Z ≫ F.μ X (Y ⊗ Z) ≫ F.map (α_ X Y Z).inv =
      (α_ (F.obj X) (F.obj Y) (F.obj Z)).inv ≫ F.μ X Y ▷ F.obj Z ≫ F.μ (X ⊗ Y) Z 
goal: CategoryTheory.MonoidalCategory.whiskerLeft (F.obj X) (F.μ Y Z) ≫
    F.μ X (CategoryTheory.MonoidalCategory.tensorObj Y Z) ≫
      F.map (CategoryTheory.MonoidalCategory.associator X Y Z).inv =
  (CategoryTheory.MonoidalCategory.associator (F.obj X) (F.obj Y) (F.obj Z)).inv ≫
    CategoryTheory.MonoidalCategory.whiskerRight (F.μ X Y) (F.obj Z) ≫
      F.μ (CategoryTheory.MonoidalCategory.tensorObj X Y) Z

full_name: CategoryTheory.OplaxMonoidalFunctor.associativity
code: /-- A oplax monoidal functor is a functor `F : C ⥤ D` between monoidal categories,
equipped with morphisms `η : F.obj (𝟙_ C) ⟶ 𝟙 _D` and `δ X Y : F.obj (X ⊗ Y) ⟶ F.obj X ⊗ F.obj Y`,
satisfying the appropriate coherences. -/
structure OplaxMonoidalFunctor extends C ⥤ D where
  /-- counit morphism -/
  η : obj (𝟙_ C) ⟶ 𝟙_ D
  /-- cotensorator -/
  δ : ∀ X Y : C, obj (X ⊗ Y) ⟶ obj X ⊗ obj Y
  δ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      δ X X' ≫ map f ▷ obj X' = map (f ▷ X') ≫ δ Y X' := by
    aesop_cat
  δ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      δ X' X ≫ obj X' ◁ map f = map (X' ◁ f) ≫ δ X' Y := by
    aesop_cat
  /-- associativity of the tensorator -/
  associativity :
    ∀ X Y Z : C,
      δ (X ⊗ Y) Z ≫ δ X Y ▷ obj Z ≫ (α_ (obj X) (obj Y) (obj Z)).hom =
        map (α_ X Y Z).hom ≫ δ X (Y ⊗ Z) ≫ obj X ◁ δ Y Z := by
    aesop_cat
  -- unitality
  left_unitality : ∀ X : C, (λ_ (obj X)).inv = map (λ_ X).inv ≫ δ (𝟙_ C) X ≫ η ▷ obj X := by
    aesop_cat
  right_unitality : ∀ X : C, (ρ_ (obj X)).inv = map (ρ_ X).inv ≫ δ X (𝟙_ C) ≫ obj X ◁ η := by
    aesop_cat
goal: self.δ (CategoryTheory.MonoidalCategory.tensorObj X Y) Z ≫
    CategoryTheory.MonoidalCategory.whiskerRight (self.δ X Y) (self.obj Z) ≫
      (CategoryTheory.MonoidalCategory.associator (self.obj X) (self.obj Y) (self.obj Z)).hom =
  self.map (CategoryTheory.MonoidalCategory.associator X Y Z).hom ≫
    self.δ X (CategoryTheory.MonoidalCategory.tensorObj Y Z) ≫
      CategoryTheory.MonoidalCategory.whiskerLeft (self.obj X) (self.δ Y Z)

full_name: CategoryTheory.OplaxMonoidalFunctor.η
code: /-- A oplax monoidal functor is a functor `F : C ⥤ D` between monoidal categories,
equipped with morphisms `η : F.obj (𝟙_ C) ⟶ 𝟙 _D` and `δ X Y : F.obj (X ⊗ Y) ⟶ F.obj X ⊗ F.obj Y`,
satisfying the appropriate coherences. -/
structure OplaxMonoidalFunctor extends C ⥤ D where
  /-- counit morphism -/
  η : obj (𝟙_ C) ⟶ 𝟙_ D
  /-- cotensorator -/
  δ : ∀ X Y : C, obj (X ⊗ Y) ⟶ obj X ⊗ obj Y
  δ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      δ X X' ≫ map f ▷ obj X' = map (f ▷ X') ≫ δ Y X' := by
    aesop_cat
  δ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      δ X' X ≫ obj X' ◁ map f = map (X' ◁ f) ≫ δ X' Y := by
    aesop_cat
  /-- associativity of the tensorator -/
  associativity :
    ∀ X Y Z : C,
      δ (X ⊗ Y) Z ≫ δ X Y ▷ obj Z ≫ (α_ (obj X) (obj Y) (obj Z)).hom =
        map (α_ X Y Z).hom ≫ δ X (Y ⊗ Z) ≫ obj X ◁ δ Y Z := by
    aesop_cat
  -- unitality
  left_unitality : ∀ X : C, (λ_ (obj X)).inv = map (λ_ X).inv ≫ δ (𝟙_ C) X ≫ η ▷ obj X := by
    aesop_cat
  right_unitality : ∀ X : C, (ρ_ (obj X)).inv = map (ρ_ X).inv ≫ δ X (𝟙_ C) ≫ obj X ◁ η := by
    aesop_cat
goal: self.obj (𝟙_ C) ⟶ 𝟙_ D

full_name: CategoryTheory.OplaxMonoidalFunctor.δ
code: /-- A oplax monoidal functor is a functor `F : C ⥤ D` between monoidal categories,
equipped with morphisms `η : F.obj (𝟙_ C) ⟶ 𝟙 _D` and `δ X Y : F.obj (X ⊗ Y) ⟶ F.obj X ⊗ F.obj Y`,
satisfying the appropriate coherences. -/
structure OplaxMonoidalFunctor extends C ⥤ D where
  /-- counit morphism -/
  η : obj (𝟙_ C) ⟶ 𝟙_ D
  /-- cotensorator -/
  δ : ∀ X Y : C, obj (X ⊗ Y) ⟶ obj X ⊗ obj Y
  δ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      δ X X' ≫ map f ▷ obj X' = map (f ▷ X') ≫ δ Y X' := by
    aesop_cat
  δ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      δ X' X ≫ obj X' ◁ map f = map (X' ◁ f) ≫ δ X' Y := by
    aesop_cat
  /-- associativity of the tensorator -/
  associativity :
    ∀ X Y Z : C,
      δ (X ⊗ Y) Z ≫ δ X Y ▷ obj Z ≫ (α_ (obj X) (obj Y) (obj Z)).hom =
        map (α_ X Y Z).hom ≫ δ X (Y ⊗ Z) ≫ obj X ◁ δ Y Z := by
    aesop_cat
  -- unitality
  left_unitality : ∀ X : C, (λ_ (obj X)).inv = map (λ_ X).inv ≫ δ (𝟙_ C) X ≫ η ▷ obj X := by
    aesop_cat
  right_unitality : ∀ X : C, (ρ_ (obj X)).inv = map (ρ_ X).inv ≫ δ X (𝟙_ C) ≫ obj X ◁ η := by
    aesop_cat
goal: self.obj (CategoryTheory.MonoidalCategory.tensorObj X Y) ⟶
  CategoryTheory.MonoidalCategory.tensorObj (self.obj X) (self.obj Y)

full_name: CategoryTheory.OplaxMonoidalFunctor.left_unitality
code: /-- A oplax monoidal functor is a functor `F : C ⥤ D` between monoidal categories,
equipped with morphisms `η : F.obj (𝟙_ C) ⟶ 𝟙 _D` and `δ X Y : F.obj (X ⊗ Y) ⟶ F.obj X ⊗ F.obj Y`,
satisfying the appropriate coherences. -/
structure OplaxMonoidalFunctor extends C ⥤ D where
  /-- counit morphism -/
  η : obj (𝟙_ C) ⟶ 𝟙_ D
  /-- cotensorator -/
  δ : ∀ X Y : C, obj (X ⊗ Y) ⟶ obj X ⊗ obj Y
  δ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      δ X X' ≫ map f ▷ obj X' = map (f ▷ X') ≫ δ Y X' := by
    aesop_cat
  δ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      δ X' X ≫ obj X' ◁ map f = map (X' ◁ f) ≫ δ X' Y := by
    aesop_cat
  /-- associativity of the tensorator -/
  associativity :
    ∀ X Y Z : C,
      δ (X ⊗ Y) Z ≫ δ X Y ▷ obj Z ≫ (α_ (obj X) (obj Y) (obj Z)).hom =
        map (α_ X Y Z).hom ≫ δ X (Y ⊗ Z) ≫ obj X ◁ δ Y Z := by
    aesop_cat
  -- unitality
  left_unitality : ∀ X : C, (λ_ (obj X)).inv = map (λ_ X).inv ≫ δ (𝟙_ C) X ≫ η ▷ obj X := by
    aesop_cat
  right_unitality : ∀ X : C, (ρ_ (obj X)).inv = map (ρ_ X).inv ≫ δ X (𝟙_ C) ≫ obj X ◁ η := by
    aesop_cat
goal: (CategoryTheory.MonoidalCategory.leftUnitor (self.obj X)).inv =
  self.map (CategoryTheory.MonoidalCategory.leftUnitor X).inv ≫
    self.δ (𝟙_ C) X ≫ CategoryTheory.MonoidalCategory.whiskerRight self.η (self.obj X)

full_name: CategoryTheory.OplaxMonoidalFunctor.right_unitality
code: /-- A oplax monoidal functor is a functor `F : C ⥤ D` between monoidal categories,
equipped with morphisms `η : F.obj (𝟙_ C) ⟶ 𝟙 _D` and `δ X Y : F.obj (X ⊗ Y) ⟶ F.obj X ⊗ F.obj Y`,
satisfying the appropriate coherences. -/
structure OplaxMonoidalFunctor extends C ⥤ D where
  /-- counit morphism -/
  η : obj (𝟙_ C) ⟶ 𝟙_ D
  /-- cotensorator -/
  δ : ∀ X Y : C, obj (X ⊗ Y) ⟶ obj X ⊗ obj Y
  δ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      δ X X' ≫ map f ▷ obj X' = map (f ▷ X') ≫ δ Y X' := by
    aesop_cat
  δ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      δ X' X ≫ obj X' ◁ map f = map (X' ◁ f) ≫ δ X' Y := by
    aesop_cat
  /-- associativity of the tensorator -/
  associativity :
    ∀ X Y Z : C,
      δ (X ⊗ Y) Z ≫ δ X Y ▷ obj Z ≫ (α_ (obj X) (obj Y) (obj Z)).hom =
        map (α_ X Y Z).hom ≫ δ X (Y ⊗ Z) ≫ obj X ◁ δ Y Z := by
    aesop_cat
  -- unitality
  left_unitality : ∀ X : C, (λ_ (obj X)).inv = map (λ_ X).inv ≫ δ (𝟙_ C) X ≫ η ▷ obj X := by
    aesop_cat
  right_unitality : ∀ X : C, (ρ_ (obj X)).inv = map (ρ_ X).inv ≫ δ X (𝟙_ C) ≫ obj X ◁ η := by
    aesop_cat
goal: (CategoryTheory.MonoidalCategory.rightUnitor (self.obj X)).inv =
  self.map (CategoryTheory.MonoidalCategory.rightUnitor X).inv ≫
    self.δ X (𝟙_ C) ≫ CategoryTheory.MonoidalCategory.whiskerLeft (self.obj X) self.η

full_name: CategoryTheory.OplaxMonoidalFunctor.δ_natural_right
code: /-- A oplax monoidal functor is a functor `F : C ⥤ D` between monoidal categories,
equipped with morphisms `η : F.obj (𝟙_ C) ⟶ 𝟙 _D` and `δ X Y : F.obj (X ⊗ Y) ⟶ F.obj X ⊗ F.obj Y`,
satisfying the appropriate coherences. -/
structure OplaxMonoidalFunctor extends C ⥤ D where
  /-- counit morphism -/
  η : obj (𝟙_ C) ⟶ 𝟙_ D
  /-- cotensorator -/
  δ : ∀ X Y : C, obj (X ⊗ Y) ⟶ obj X ⊗ obj Y
  δ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      δ X X' ≫ map f ▷ obj X' = map (f ▷ X') ≫ δ Y X' := by
    aesop_cat
  δ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      δ X' X ≫ obj X' ◁ map f = map (X' ◁ f) ≫ δ X' Y := by
    aesop_cat
  /-- associativity of the tensorator -/
  associativity :
    ∀ X Y Z : C,
      δ (X ⊗ Y) Z ≫ δ X Y ▷ obj Z ≫ (α_ (obj X) (obj Y) (obj Z)).hom =
        map (α_ X Y Z).hom ≫ δ X (Y ⊗ Z) ≫ obj X ◁ δ Y Z := by
    aesop_cat
  -- unitality
  left_unitality : ∀ X : C, (λ_ (obj X)).inv = map (λ_ X).inv ≫ δ (𝟙_ C) X ≫ η ▷ obj X := by
    aesop_cat
  right_unitality : ∀ X : C, (ρ_ (obj X)).inv = map (ρ_ X).inv ≫ δ X (𝟙_ C) ≫ obj X ◁ η := by
    aesop_cat
goal: self.δ X' X ≫ CategoryTheory.MonoidalCategory.whiskerLeft (self.obj X') (self.map f) =
  self.map (CategoryTheory.MonoidalCategory.whiskerLeft X' f) ≫ self.δ X' Y

full_name: CategoryTheory.OplaxMonoidalFunctor
code: /-- A oplax monoidal functor is a functor `F : C ⥤ D` between monoidal categories,
equipped with morphisms `η : F.obj (𝟙_ C) ⟶ 𝟙 _D` and `δ X Y : F.obj (X ⊗ Y) ⟶ F.obj X ⊗ F.obj Y`,
satisfying the appropriate coherences. -/
structure OplaxMonoidalFunctor extends C ⥤ D where
  /-- counit morphism -/
  η : obj (𝟙_ C) ⟶ 𝟙_ D
  /-- cotensorator -/
  δ : ∀ X Y : C, obj (X ⊗ Y) ⟶ obj X ⊗ obj Y
  δ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      δ X X' ≫ map f ▷ obj X' = map (f ▷ X') ≫ δ Y X' := by
    aesop_cat
  δ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      δ X' X ≫ obj X' ◁ map f = map (X' ◁ f) ≫ δ X' Y := by
    aesop_cat
  /-- associativity of the tensorator -/
  associativity :
    ∀ X Y Z : C,
      δ (X ⊗ Y) Z ≫ δ X Y ▷ obj Z ≫ (α_ (obj X) (obj Y) (obj Z)).hom =
        map (α_ X Y Z).hom ≫ δ X (Y ⊗ Z) ≫ obj X ◁ δ Y Z := by
    aesop_cat
  -- unitality
  left_unitality : ∀ X : C, (λ_ (obj X)).inv = map (λ_ X).inv ≫ δ (𝟙_ C) X ≫ η ▷ obj X := by
    aesop_cat
  right_unitality : ∀ X : C, (ρ_ (obj X)).inv = map (ρ_ X).inv ≫ δ X (𝟙_ C) ≫ obj X ◁ η := by
    aesop_cat
goal: Type (max (max (max u₁ u₂) v₁) v₂)

full_name: CategoryTheory.OplaxMonoidalFunctor.δ_natural_left
code: /-- A oplax monoidal functor is a functor `F : C ⥤ D` between monoidal categories,
equipped with morphisms `η : F.obj (𝟙_ C) ⟶ 𝟙 _D` and `δ X Y : F.obj (X ⊗ Y) ⟶ F.obj X ⊗ F.obj Y`,
satisfying the appropriate coherences. -/
structure OplaxMonoidalFunctor extends C ⥤ D where
  /-- counit morphism -/
  η : obj (𝟙_ C) ⟶ 𝟙_ D
  /-- cotensorator -/
  δ : ∀ X Y : C, obj (X ⊗ Y) ⟶ obj X ⊗ obj Y
  δ_natural_left :
    ∀ {X Y : C} (f : X ⟶ Y) (X' : C),
      δ X X' ≫ map f ▷ obj X' = map (f ▷ X') ≫ δ Y X' := by
    aesop_cat
  δ_natural_right :
    ∀ {X Y : C} (X' : C) (f : X ⟶ Y) ,
      δ X' X ≫ obj X' ◁ map f = map (X' ◁ f) ≫ δ X' Y := by
    aesop_cat
  /-- associativity of the tensorator -/
  associativity :
    ∀ X Y Z : C,
      δ (X ⊗ Y) Z ≫ δ X Y ▷ obj Z ≫ (α_ (obj X) (obj Y) (obj Z)).hom =
        map (α_ X Y Z).hom ≫ δ X (Y ⊗ Z) ≫ obj X ◁ δ Y Z := by
    aesop_cat
  -- unitality
  left_unitality : ∀ X : C, (λ_ (obj X)).inv = map (λ_ X).inv ≫ δ (𝟙_ C) X ≫ η ▷ obj X := by
    aesop_cat
  right_unitality : ∀ X : C, (ρ_ (obj X)).inv = map (ρ_ X).inv ≫ δ X (𝟙_ C) ≫ obj X ◁ η := by
    aesop_cat
goal: self.δ X X' ≫ CategoryTheory.MonoidalCategory.whiskerRight (self.map f) (self.obj X') =
  self.map (CategoryTheory.MonoidalCategory.whiskerRight f X') ≫ self.δ Y X'

full_name: CategoryTheory.OplaxMonoidalFunctor.δ_natural
code: @[reassoc (attr := simp)]
theorem OplaxMonoidalFunctor.δ_natural (F : OplaxMonoidalFunctor C D) {X Y X' Y' : C}
    (f : X ⟶ Y) (g : X' ⟶ Y') :
      F.δ X X' ≫ (F.map f ⊗ F.map g) = F.map (f ⊗ g) ≫ F.δ Y Y' 
goal: F.δ X X' ≫ CategoryTheory.MonoidalCategory.tensorHom (F.map f) (F.map g) =
  F.map (CategoryTheory.MonoidalCategory.tensorHom f g) ≫ F.δ Y Y'

full_name: CategoryTheory.OplaxMonoidalFunctor.left_unitality_hom
code: @[reassoc (attr := simp)]
theorem OplaxMonoidalFunctor.left_unitality_hom (F : OplaxMonoidalFunctor C D) (X : C) :
    F.δ (𝟙_ C) X ≫ F.η ▷ F.obj X ≫ (λ_ (F.obj X)).hom = F.map (λ_ X).hom 
goal: F.δ (𝟙_ C) X ≫
    CategoryTheory.MonoidalCategory.whiskerRight F.η (F.obj X) ≫
      (CategoryTheory.MonoidalCategory.leftUnitor (F.obj X)).hom =
  F.map (CategoryTheory.MonoidalCategory.leftUnitor X).hom

full_name: CategoryTheory.OplaxMonoidalFunctor.right_unitality_hom
code: @[reassoc (attr := simp)]
theorem OplaxMonoidalFunctor.right_unitality_hom (F : OplaxMonoidalFunctor C D) (X : C) :
    F.δ X (𝟙_ C) ≫ F.obj X ◁ F.η ≫ (ρ_ (F.obj X)).hom = F.map (ρ_ X).hom 
goal: F.δ X (𝟙_ C) ≫
    CategoryTheory.MonoidalCategory.whiskerLeft (F.obj X) F.η ≫
      (CategoryTheory.MonoidalCategory.rightUnitor (F.obj X)).hom =
  F.map (CategoryTheory.MonoidalCategory.rightUnitor X).hom

full_name: CategoryTheory.OplaxMonoidalFunctor.associativity_inv
code: @[reassoc (attr := simp)]
theorem OplaxMonoidalFunctor.associativity_inv (F : OplaxMonoidalFunctor C D) (X Y Z : C) :
    F.δ X (Y ⊗ Z) ≫ F.obj X ◁ F.δ Y Z ≫ (α_ (F.obj X) (F.obj Y) (F.obj Z)).inv =
      F.map (α_ X Y Z).inv ≫ F.δ (X ⊗ Y) Z ≫ F.δ X Y ▷ F.obj Z 
goal: F.δ X (CategoryTheory.MonoidalCategory.tensorObj Y Z) ≫
    CategoryTheory.MonoidalCategory.whiskerLeft (F.obj X) (F.δ Y Z) ≫
      (CategoryTheory.MonoidalCategory.associator (F.obj X) (F.obj Y) (F.obj Z)).inv =
  F.map (CategoryTheory.MonoidalCategory.associator X Y Z).inv ≫
    F.δ (CategoryTheory.MonoidalCategory.tensorObj X Y) Z ≫
      CategoryTheory.MonoidalCategory.whiskerRight (F.δ X Y) (F.obj Z)

full_name: CategoryTheory.MonoidalFunctor.ε_isIso
code: /--
A monoidal functor is a lax monoidal functor for which the tensorator and unitor are isomorphisms.

See <https://stacks.math.columbia.edu/tag/0FFL>.
-/
structure MonoidalFunctor extends LaxMonoidalFunctor.{v₁, v₂} C D where
  ε_isIso : IsIso ε := by infer_instance
  μ_isIso : ∀ X Y : C, IsIso (μ X Y) := by infer_instance
goal: CategoryTheory.IsIso self.ε

full_name: CategoryTheory.MonoidalFunctor.μ_isIso
code: /--
A monoidal functor is a lax monoidal functor for which the tensorator and unitor are isomorphisms.

See <https://stacks.math.columbia.edu/tag/0FFL>.
-/
structure MonoidalFunctor extends LaxMonoidalFunctor.{v₁, v₂} C D where
  ε_isIso : IsIso ε := by infer_instance
  μ_isIso : ∀ X Y : C, IsIso (μ X Y) := by infer_instance
goal: CategoryTheory.IsIso (self.μ X Y)

full_name: CategoryTheory.MonoidalFunctor
code: /--
A monoidal functor is a lax monoidal functor for which the tensorator and unitor are isomorphisms.

See <https://stacks.math.columbia.edu/tag/0FFL>.
-/
structure MonoidalFunctor extends LaxMonoidalFunctor.{v₁, v₂} C D where
  ε_isIso : IsIso ε := by infer_instance
  μ_isIso : ∀ X Y : C, IsIso (μ X Y) := by infer_instance
goal: Type (max (max (max u₁ u₂) v₁) v₂)

full_name: CategoryTheory.MonoidalFunctor.εIso
code: /-- The unit morphism of a (strong) monoidal functor as an isomorphism.
-/
noncomputable def MonoidalFunctor.εIso (F : MonoidalFunctor.{v₁, v₂} C D) :
    𝟙_ D ≅ F.obj (𝟙_ C) 
goal: 𝟙_ D ≅ F.obj (𝟙_ C)

full_name: CategoryTheory.MonoidalFunctor.μIso
code: /-- The tensorator of a (strong) monoidal functor as an isomorphism.
-/
noncomputable def MonoidalFunctor.μIso (F : MonoidalFunctor.{v₁, v₂} C D) (X Y : C) :
    F.obj X ⊗ F.obj Y ≅ F.obj (X ⊗ Y) 
goal: CategoryTheory.MonoidalCategory.tensorObj (F.obj X) (F.obj Y) ≅ F.obj (CategoryTheory.MonoidalCategory.tensorObj X Y)

full_name: CategoryTheory.MonoidalFunctor.toOplaxMonoidalFunctor
code: /-- The underlying oplax monoidal functor of a (strong) monoidal functor. -/
@[simps]
noncomputable def MonoidalFunctor.toOplaxMonoidalFunctor (F : MonoidalFunctor C D) :
    OplaxMonoidalFunctor C D 
goal: CategoryTheory.OplaxMonoidalFunctor C D

full_name: CategoryTheory.MonoidalFunctor.toOplaxMonoidalFunctor_δ
code: /-- The underlying oplax monoidal functor of a (strong) monoidal functor. -/
@[simps]
noncomputable def MonoidalFunctor.toOplaxMonoidalFunctor (F : MonoidalFunctor C D) :
    OplaxMonoidalFunctor C D 
goal: F.toOplaxMonoidalFunctor.δ X Y = CategoryTheory.inv (F.μ X Y)

full_name: CategoryTheory.MonoidalFunctor.toOplaxMonoidalFunctor_η
code: /-- The underlying oplax monoidal functor of a (strong) monoidal functor. -/
@[simps]
noncomputable def MonoidalFunctor.toOplaxMonoidalFunctor (F : MonoidalFunctor C D) :
    OplaxMonoidalFunctor C D 
goal: F.toOplaxMonoidalFunctor.η = CategoryTheory.inv F.ε

full_name: CategoryTheory.MonoidalFunctor.toOplaxMonoidalFunctor_toFunctor
code: /-- The underlying oplax monoidal functor of a (strong) monoidal functor. -/
@[simps]
noncomputable def MonoidalFunctor.toOplaxMonoidalFunctor (F : MonoidalFunctor C D) :
    OplaxMonoidalFunctor C D 
goal: F.toOplaxMonoidalFunctor.toFunctor = F.toFunctor

full_name: CategoryTheory.LaxMonoidalFunctor.id_μ
code: /-- The identity lax monoidal functor. -/
@[simps]
def id : LaxMonoidalFunctor.{v₁, v₁} C C 
goal: (CategoryTheory.LaxMonoidalFunctor.id C).μ X Y =
  𝟙 (CategoryTheory.MonoidalCategory.tensorObj ((𝟭 C).obj X) ((𝟭 C).obj Y))

full_name: CategoryTheory.LaxMonoidalFunctor.id_ε
code: /-- The identity lax monoidal functor. -/
@[simps]
def id : LaxMonoidalFunctor.{v₁, v₁} C C 
goal: (CategoryTheory.LaxMonoidalFunctor.id C).ε = 𝟙 (𝟙_ C)

full_name: CategoryTheory.LaxMonoidalFunctor.id
code: /-- The identity lax monoidal functor. -/
@[simps]
def id : LaxMonoidalFunctor.{v₁, v₁} C C 
goal: CategoryTheory.LaxMonoidalFunctor C C

full_name: CategoryTheory.LaxMonoidalFunctor.id_toFunctor
code: /-- The identity lax monoidal functor. -/
@[simps]
def id : LaxMonoidalFunctor.{v₁, v₁} C C 
goal: (CategoryTheory.LaxMonoidalFunctor.id C).toFunctor = 𝟭 C

full_name: CategoryTheory.LaxMonoidalFunctor.instInhabited
code: instance : Inhabited (LaxMonoidalFunctor C C) 
goal: Inhabited (CategoryTheory.LaxMonoidalFunctor C C)

full_name: CategoryTheory.OplaxMonoidalFunctor.id_η
code: /-- The identity lax monoidal functor. -/
@[simps]
def id : OplaxMonoidalFunctor.{v₁, v₁} C C 
goal: (CategoryTheory.OplaxMonoidalFunctor.id C).η = 𝟙 ((𝟭 C).obj (𝟙_ C))

full_name: CategoryTheory.OplaxMonoidalFunctor.id_δ
code: /-- The identity lax monoidal functor. -/
@[simps]
def id : OplaxMonoidalFunctor.{v₁, v₁} C C 
goal: (CategoryTheory.OplaxMonoidalFunctor.id C).δ X Y = 𝟙 ((𝟭 C).obj (CategoryTheory.MonoidalCategory.tensorObj X Y))

full_name: CategoryTheory.OplaxMonoidalFunctor.id
code: /-- The identity lax monoidal functor. -/
@[simps]
def id : OplaxMonoidalFunctor.{v₁, v₁} C C 
goal: CategoryTheory.OplaxMonoidalFunctor C C

full_name: CategoryTheory.OplaxMonoidalFunctor.id_toFunctor
code: /-- The identity lax monoidal functor. -/
@[simps]
def id : OplaxMonoidalFunctor.{v₁, v₁} C C 
goal: (CategoryTheory.OplaxMonoidalFunctor.id C).toFunctor = 𝟭 C

full_name: CategoryTheory.OplaxMonoidalFunctor.instInhabited
code: instance : Inhabited (OplaxMonoidalFunctor C C) 
goal: Inhabited (CategoryTheory.OplaxMonoidalFunctor C C)

full_name: CategoryTheory.MonoidalFunctor.map_tensor
code: @[reassoc]
theorem map_tensor {X Y X' Y' : C} (f : X ⟶ Y) (g : X' ⟶ Y') :
    F.map (f ⊗ g) = inv (F.μ X X') ≫ (F.map f ⊗ F.map g) ≫ F.μ Y Y' 
goal: F.map (CategoryTheory.MonoidalCategory.tensorHom f g) =
  CategoryTheory.inv (F.μ X X') ≫ CategoryTheory.MonoidalCategory.tensorHom (F.map f) (F.map g) ≫ F.μ Y Y'

full_name: CategoryTheory.MonoidalFunctor.map_whiskerLeft
code: @[reassoc]
theorem map_whiskerLeft (X : C) {Y Z : C} (f : Y ⟶ Z) :
    F.map (X ◁ f) = inv (F.μ X Y) ≫ F.obj X ◁ F.map f ≫ F.μ X Z 
goal: F.map (CategoryTheory.MonoidalCategory.whiskerLeft X f) =
  CategoryTheory.inv (F.μ X Y) ≫ CategoryTheory.MonoidalCategory.whiskerLeft (F.obj X) (F.map f) ≫ F.μ X Z

full_name: CategoryTheory.MonoidalFunctor.map_whiskerRight
code: @[reassoc]
theorem map_whiskerRight {X Y : C} (f : X ⟶ Y) (Z : C) :
    F.map (f ▷ Z) = inv (F.μ X Z) ≫ F.map f ▷ F.obj Z ≫ F.μ Y Z 
goal: F.map (CategoryTheory.MonoidalCategory.whiskerRight f Z) =
  CategoryTheory.inv (F.μ X Z) ≫ CategoryTheory.MonoidalCategory.whiskerRight (F.map f) (F.obj Z) ≫ F.μ Y Z

full_name: CategoryTheory.MonoidalFunctor.map_leftUnitor
code: @[reassoc]
theorem map_leftUnitor (X : C) :
    F.map (λ_ X).hom = inv (F.μ (𝟙_ C) X) ≫ inv F.ε ▷ F.obj X ≫ (λ_ (F.obj X)).hom 
goal: F.map (CategoryTheory.MonoidalCategory.leftUnitor X).hom =
  CategoryTheory.inv (F.μ (𝟙_ C) X) ≫
    CategoryTheory.MonoidalCategory.whiskerRight (CategoryTheory.inv F.ε) (F.obj X) ≫
      (CategoryTheory.MonoidalCategory.leftUnitor (F.obj X)).hom

full_name: CategoryTheory.MonoidalFunctor.map_rightUnitor
code: @[reassoc]
theorem map_rightUnitor (X : C) :
    F.map (ρ_ X).hom = inv (F.μ X (𝟙_ C)) ≫ F.obj X ◁ inv F.ε ≫ (ρ_ (F.obj X)).hom 
goal: F.map (CategoryTheory.MonoidalCategory.rightUnitor X).hom =
  CategoryTheory.inv (F.μ X (𝟙_ C)) ≫
    CategoryTheory.MonoidalCategory.whiskerLeft (F.obj X) (CategoryTheory.inv F.ε) ≫
      (CategoryTheory.MonoidalCategory.rightUnitor (F.obj X)).hom

full_name: CategoryTheory.MonoidalFunctor.μNatIso
code: /-- The tensorator as a natural isomorphism. -/
noncomputable def μNatIso :
    Functor.prod F.toFunctor F.toFunctor ⋙ tensor D ≅ tensor C ⋙ F.toFunctor 
goal: F.prod F.toFunctor ⋙ CategoryTheory.MonoidalCategory.tensor D ≅ CategoryTheory.MonoidalCategory.tensor C ⋙ F.toFunctor

full_name: CategoryTheory.MonoidalFunctor.μIso_hom
code: @[simp]
theorem μIso_hom (X Y : C) : (F.μIso X Y).hom = F.μ X Y 
goal: (F.μIso X Y).hom = F.μ X Y

full_name: CategoryTheory.MonoidalFunctor.μ_inv_hom_id
code: @[reassoc (attr := simp)]
theorem μ_inv_hom_id (X Y : C) : (F.μIso X Y).inv ≫ F.μ X Y = 𝟙 _ 
goal: (F.μIso X Y).inv ≫ F.μ X Y = 𝟙 (F.obj (CategoryTheory.MonoidalCategory.tensorObj X Y))

full_name: CategoryTheory.MonoidalFunctor.μ_hom_inv_id
code: @[simp]
theorem μ_hom_inv_id (X Y : C) : F.μ X Y ≫ (F.μIso X Y).inv = 𝟙 _ 
goal: F.μ X Y ≫ (F.μIso X Y).inv = 𝟙 (CategoryTheory.MonoidalCategory.tensorObj (F.obj X) (F.obj Y))

full_name: CategoryTheory.MonoidalFunctor.εIso_hom
code: @[simp]
theorem εIso_hom : F.εIso.hom = F.ε 
goal: F.εIso.hom = F.ε

full_name: CategoryTheory.MonoidalFunctor.ε_inv_hom_id
code: @[reassoc (attr := simp)]
theorem ε_inv_hom_id : F.εIso.inv ≫ F.ε = 𝟙 _ 
goal: F.εIso.inv ≫ F.ε = 𝟙 (F.obj (𝟙_ C))

full_name: CategoryTheory.MonoidalFunctor.ε_hom_inv_id
code: @[simp]
theorem ε_hom_inv_id : F.ε ≫ F.εIso.inv = 𝟙 _ 
goal: F.ε ≫ F.εIso.inv = 𝟙 (𝟙_ D)

full_name: CategoryTheory.MonoidalFunctor.commTensorLeft_inv_app
code: /-- Monoidal functors commute with left tensoring up to isomorphism -/
@[simps!]
noncomputable def commTensorLeft (X : C) :
    F.toFunctor ⋙ tensorLeft (F.toFunctor.obj X) ≅ tensorLeft X ⋙ F.toFunctor 
goal: ∀ (X_1 : C), (F.commTensorLeft X).inv.app X_1 = (F.μIso X X_1).inv

full_name: CategoryTheory.MonoidalFunctor.commTensorLeft
code: /-- Monoidal functors commute with left tensoring up to isomorphism -/
@[simps!]
noncomputable def commTensorLeft (X : C) :
    F.toFunctor ⋙ tensorLeft (F.toFunctor.obj X) ≅ tensorLeft X ⋙ F.toFunctor 
goal: F.toFunctor ⋙ CategoryTheory.MonoidalCategory.tensorLeft (F.obj X) ≅
  CategoryTheory.MonoidalCategory.tensorLeft X ⋙ F.toFunctor

full_name: CategoryTheory.MonoidalFunctor.commTensorLeft_hom_app
code: /-- Monoidal functors commute with left tensoring up to isomorphism -/
@[simps!]
noncomputable def commTensorLeft (X : C) :
    F.toFunctor ⋙ tensorLeft (F.toFunctor.obj X) ≅ tensorLeft X ⋙ F.toFunctor 
goal: ∀ (X_1 : C), (F.commTensorLeft X).hom.app X_1 = F.μ X X_1

full_name: CategoryTheory.MonoidalFunctor.commTensorRight
code: /-- Monoidal functors commute with right tensoring up to isomorphism -/
@[simps!]
noncomputable def commTensorRight (X : C) :
    F.toFunctor ⋙ tensorRight (F.toFunctor.obj X) ≅ tensorRight X ⋙ F.toFunctor 
goal: F.toFunctor ⋙ CategoryTheory.MonoidalCategory.tensorRight (F.obj X) ≅
  CategoryTheory.MonoidalCategory.tensorRight X ⋙ F.toFunctor

full_name: CategoryTheory.MonoidalFunctor.commTensorRight_inv_app
code: /-- Monoidal functors commute with right tensoring up to isomorphism -/
@[simps!]
noncomputable def commTensorRight (X : C) :
    F.toFunctor ⋙ tensorRight (F.toFunctor.obj X) ≅ tensorRight X ⋙ F.toFunctor 
goal: ∀ (X_1 : C), (F.commTensorRight X).inv.app X_1 = (F.μIso X_1 X).inv

full_name: CategoryTheory.MonoidalFunctor.commTensorRight_hom_app
code: /-- Monoidal functors commute with right tensoring up to isomorphism -/
@[simps!]
noncomputable def commTensorRight (X : C) :
    F.toFunctor ⋙ tensorRight (F.toFunctor.obj X) ≅ tensorRight X ⋙ F.toFunctor 
goal: ∀ (X_1 : C), (F.commTensorRight X).hom.app X_1 = F.μ X_1 X

full_name: CategoryTheory.MonoidalFunctor.id_toLaxMonoidalFunctor_μ
code: /-- The identity monoidal functor. -/
@[simps]
def id : MonoidalFunctor.{v₁, v₁} C C 
goal: (CategoryTheory.MonoidalFunctor.id C).μ X Y = 𝟙 (CategoryTheory.MonoidalCategory.tensorObj ((𝟭 C).obj X) ((𝟭 C).obj Y))

full_name: CategoryTheory.MonoidalFunctor.id_toLaxMonoidalFunctor_ε
code: /-- The identity monoidal functor. -/
@[simps]
def id : MonoidalFunctor.{v₁, v₁} C C 
goal: (CategoryTheory.MonoidalFunctor.id C).ε = 𝟙 (𝟙_ C)

full_name: CategoryTheory.MonoidalFunctor.id
code: /-- The identity monoidal functor. -/
@[simps]
def id : MonoidalFunctor.{v₁, v₁} C C 
goal: CategoryTheory.MonoidalFunctor C C

full_name: CategoryTheory.MonoidalFunctor.id_toLaxMonoidalFunctor_toFunctor
code: /-- The identity monoidal functor. -/
@[simps]
def id : MonoidalFunctor.{v₁, v₁} C C 
goal: (CategoryTheory.MonoidalFunctor.id C).toFunctor = 𝟭 C

full_name: CategoryTheory.MonoidalFunctor.instInhabited
code: instance : Inhabited (MonoidalFunctor C C) 
goal: Inhabited (CategoryTheory.MonoidalFunctor C C)

full_name: CategoryTheory.LaxMonoidalFunctor.comp_toFunctor
code: /-- The composition of two lax monoidal functors is again lax monoidal. -/
@[simps]
def comp : LaxMonoidalFunctor.{v₁, v₃} C E 
goal: (F ⊗⋙ G).toFunctor = F.toFunctor ⋙ G.toFunctor

full_name: CategoryTheory.LaxMonoidalFunctor.comp_μ
code: /-- The composition of two lax monoidal functors is again lax monoidal. -/
@[simps]
def comp : LaxMonoidalFunctor.{v₁, v₃} C E 
goal: (F ⊗⋙ G).μ X Y = G.μ (F.obj X) (F.obj Y) ≫ G.map (F.μ X Y)

full_name: CategoryTheory.LaxMonoidalFunctor.comp_ε
code: /-- The composition of two lax monoidal functors is again lax monoidal. -/
@[simps]
def comp : LaxMonoidalFunctor.{v₁, v₃} C E 
goal: (F ⊗⋙ G).ε = G.ε ≫ G.map F.ε

full_name: CategoryTheory.LaxMonoidalFunctor.comp
code: /-- The composition of two lax monoidal functors is again lax monoidal. -/
@[simps]
def comp : LaxMonoidalFunctor.{v₁, v₃} C E 
goal: CategoryTheory.LaxMonoidalFunctor C E

full_name: CategoryTheory.LaxMonoidalFunctor._aux_Mathlib_CategoryTheory_Monoidal_Functor___unexpand_CategoryTheory_LaxMonoidalFunctor_comp_1
code: @[inherit_doc]
infixr:80 " ⊗⋙ " => comp
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.LaxMonoidalFunctor.«_aux_Mathlib_CategoryTheory_Monoidal_Functor___macroRules_CategoryTheory_LaxMonoidalFunctor_term_⊗⋙__1»
code: @[inherit_doc]
infixr:80 " ⊗⋙ " => comp
goal: Lean.Macro

full_name: CategoryTheory.OplaxMonoidalFunctor.comp_δ
code: /-- The composition of two oplax monoidal functors is again oplax monoidal. -/
@[simps]
def comp : OplaxMonoidalFunctor.{v₁, v₃} C E 
goal: (F ⊗⋙ G).δ X Y = G.map (F.δ X Y) ≫ G.δ (F.obj X) (F.obj Y)

full_name: CategoryTheory.OplaxMonoidalFunctor.comp_η
code: /-- The composition of two oplax monoidal functors is again oplax monoidal. -/
@[simps]
def comp : OplaxMonoidalFunctor.{v₁, v₃} C E 
goal: (F ⊗⋙ G).η = G.map F.η ≫ G.η

full_name: CategoryTheory.OplaxMonoidalFunctor.comp
code: /-- The composition of two oplax monoidal functors is again oplax monoidal. -/
@[simps]
def comp : OplaxMonoidalFunctor.{v₁, v₃} C E 
goal: CategoryTheory.OplaxMonoidalFunctor C E

full_name: CategoryTheory.OplaxMonoidalFunctor.comp_toFunctor
code: /-- The composition of two oplax monoidal functors is again oplax monoidal. -/
@[simps]
def comp : OplaxMonoidalFunctor.{v₁, v₃} C E 
goal: (F ⊗⋙ G).toFunctor = F.toFunctor ⋙ G.toFunctor

full_name: CategoryTheory.OplaxMonoidalFunctor._aux_Mathlib_CategoryTheory_Monoidal_Functor___unexpand_CategoryTheory_OplaxMonoidalFunctor_comp_1
code: @[inherit_doc]
infixr:80 " ⊗⋙ " => comp
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.OplaxMonoidalFunctor.«_aux_Mathlib_CategoryTheory_Monoidal_Functor___macroRules_CategoryTheory_OplaxMonoidalFunctor_term_⊗⋙__1»
code: @[inherit_doc]
infixr:80 " ⊗⋙ " => comp
goal: Lean.Macro

full_name: CategoryTheory.LaxMonoidalFunctor.prod_ε
code: /-- The cartesian product of two lax monoidal functors is lax monoidal. -/
@[simps]
def prod : LaxMonoidalFunctor (B × D) (C × E) 
goal: (F.prod G).ε = (F.ε, G.ε)

full_name: CategoryTheory.LaxMonoidalFunctor.prod_toFunctor
code: /-- The cartesian product of two lax monoidal functors is lax monoidal. -/
@[simps]
def prod : LaxMonoidalFunctor (B × D) (C × E) 
goal: (F.prod G).toFunctor = F.prod G.toFunctor

full_name: CategoryTheory.LaxMonoidalFunctor.prod_μ
code: /-- The cartesian product of two lax monoidal functors is lax monoidal. -/
@[simps]
def prod : LaxMonoidalFunctor (B × D) (C × E) 
goal: (F.prod G).μ X Y = (F.μ X.1 Y.1, G.μ X.2 Y.2)

full_name: CategoryTheory.LaxMonoidalFunctor.prod
code: /-- The cartesian product of two lax monoidal functors is lax monoidal. -/
@[simps]
def prod : LaxMonoidalFunctor (B × D) (C × E) 
goal: CategoryTheory.LaxMonoidalFunctor (B × D) (C × E)

full_name: CategoryTheory.MonoidalFunctor.diag_toLaxMonoidalFunctor_toFunctor
code: /-- The diagonal functor as a monoidal functor. -/
@[simps]
def diag : MonoidalFunctor C (C × C) 
goal: (CategoryTheory.MonoidalFunctor.diag C).toFunctor = CategoryTheory.Functor.diag C

full_name: CategoryTheory.MonoidalFunctor.diag_toLaxMonoidalFunctor_ε
code: /-- The diagonal functor as a monoidal functor. -/
@[simps]
def diag : MonoidalFunctor C (C × C) 
goal: (CategoryTheory.MonoidalFunctor.diag C).ε = 𝟙 (𝟙_ (C × C))

full_name: CategoryTheory.MonoidalFunctor.diag
code: /-- The diagonal functor as a monoidal functor. -/
@[simps]
def diag : MonoidalFunctor C (C × C) 
goal: CategoryTheory.MonoidalFunctor C (C × C)

full_name: CategoryTheory.MonoidalFunctor.diag_toLaxMonoidalFunctor_μ
code: /-- The diagonal functor as a monoidal functor. -/
@[simps]
def diag : MonoidalFunctor C (C × C) 
goal: (CategoryTheory.MonoidalFunctor.diag C).μ X Y =
  𝟙
    (CategoryTheory.MonoidalCategory.tensorObj ((CategoryTheory.Functor.diag C).obj X)
      ((CategoryTheory.Functor.diag C).obj Y))

full_name: CategoryTheory.LaxMonoidalFunctor.prod'
code: /-- The cartesian product of two lax monoidal functors starting from the same monoidal category `C`
    is lax monoidal. -/
def prod' : LaxMonoidalFunctor C (D × E) 
goal: CategoryTheory.LaxMonoidalFunctor C (D × E)

full_name: CategoryTheory.LaxMonoidalFunctor.prod'_toFunctor
code: @[simp]
theorem prod'_toFunctor : (F.prod' G).toFunctor = F.toFunctor.prod' G.toFunctor 
goal: (F.prod' G).toFunctor = F.prod' G.toFunctor

full_name: CategoryTheory.LaxMonoidalFunctor.prod'_ε
code: @[simp]
theorem prod'_ε : (F.prod' G).ε = (F.ε, G.ε) 
goal: (F.prod' G).ε = (F.ε, G.ε)

full_name: CategoryTheory.LaxMonoidalFunctor.prod'_μ
code: @[simp]
theorem prod'_μ (X Y : C) : (F.prod' G).μ X Y = (F.μ X Y, G.μ X Y) 
goal: (F.prod' G).μ X Y = (F.μ X Y, G.μ X Y)

full_name: CategoryTheory.MonoidalFunctor.comp
code: /-- The composition of two monoidal functors is again monoidal. -/
@[simps]
def comp : MonoidalFunctor.{v₁, v₃} C E 
goal: CategoryTheory.MonoidalFunctor C E

full_name: CategoryTheory.MonoidalFunctor.comp_toLaxMonoidalFunctor
code: /-- The composition of two monoidal functors is again monoidal. -/
@[simps]
def comp : MonoidalFunctor.{v₁, v₃} C E 
goal: (F ⊗⋙ G).toLaxMonoidalFunctor = F.toLaxMonoidalFunctor ⊗⋙ G.toLaxMonoidalFunctor

full_name: CategoryTheory.MonoidalFunctor._aux_Mathlib_CategoryTheory_Monoidal_Functor___unexpand_CategoryTheory_MonoidalFunctor_comp_1
code: @[inherit_doc]
infixr:80
  " ⊗⋙ " =>-- We overload notation; potentially dangerous, but it seems to work.
  comp
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.MonoidalFunctor.«_aux_Mathlib_CategoryTheory_Monoidal_Functor___macroRules_CategoryTheory_MonoidalFunctor_term_⊗⋙__1»
code: @[inherit_doc]
infixr:80
  " ⊗⋙ " =>-- We overload notation; potentially dangerous, but it seems to work.
  comp
goal: Lean.Macro

full_name: CategoryTheory.MonoidalFunctor.prod
code: /-- The cartesian product of two monoidal functors is monoidal. -/
@[simps]
def prod : MonoidalFunctor (B × D) (C × E) 
goal: CategoryTheory.MonoidalFunctor (B × D) (C × E)

full_name: CategoryTheory.MonoidalFunctor.prod_toLaxMonoidalFunctor
code: /-- The cartesian product of two monoidal functors is monoidal. -/
@[simps]
def prod : MonoidalFunctor (B × D) (C × E) 
goal: (F.prod G).toLaxMonoidalFunctor = F.prod G.toLaxMonoidalFunctor

full_name: CategoryTheory.MonoidalFunctor.prod'
code: /-- The cartesian product of two monoidal functors starting from the same monoidal category `C`
    is monoidal. -/
def prod' : MonoidalFunctor C (D × E) 
goal: CategoryTheory.MonoidalFunctor C (D × E)

full_name: CategoryTheory.MonoidalFunctor.prod'_toLaxMonoidalFunctor
code: @[simp]
theorem prod'_toLaxMonoidalFunctor :
    (F.prod' G).toLaxMonoidalFunctor = F.toLaxMonoidalFunctor.prod' G.toLaxMonoidalFunctor 
goal: (F.prod' G).toLaxMonoidalFunctor = F.prod' G.toLaxMonoidalFunctor

full_name: CategoryTheory.monoidalAdjoint
code: /-- If we have a right adjoint functor `G` to a monoidal functor `F`, then `G` has a lax monoidal
structure as well.
-/
@[simp]
noncomputable def monoidalAdjoint :
    LaxMonoidalFunctor D C 
goal: CategoryTheory.LaxMonoidalFunctor D C

full_name: CategoryTheory.instIsIsoεMonoidalAdjointOfIsEquivalence
code: instance [F.IsEquivalence] : IsIso (monoidalAdjoint F h).ε 
goal: CategoryTheory.IsIso (CategoryTheory.monoidalAdjoint F h).ε

full_name: CategoryTheory.instIsIsoμMonoidalAdjointOfIsEquivalence
code: instance (X Y : D) [F.IsEquivalence] : IsIso ((monoidalAdjoint F h).μ X Y) 
goal: CategoryTheory.IsIso ((CategoryTheory.monoidalAdjoint F h).μ X Y)

full_name: CategoryTheory.monoidalInverse_toLaxMonoidalFunctor
code: /-- If a monoidal functor `F` is an equivalence of categories then its inverse is also monoidal. -/
@[simps]
noncomputable def monoidalInverse [F.IsEquivalence] :
    MonoidalFunctor D C 
goal: (CategoryTheory.monoidalInverse F h).toLaxMonoidalFunctor = CategoryTheory.monoidalAdjoint F h

full_name: CategoryTheory.monoidalInverse
code: /-- If a monoidal functor `F` is an equivalence of categories then its inverse is also monoidal. -/
@[simps]
noncomputable def monoidalInverse [F.IsEquivalence] :
    MonoidalFunctor D C 
goal: CategoryTheory.MonoidalFunctor D C