File: Mathlib/CategoryTheory/Monoidal/OfHasFiniteProducts.lean

full_name: CategoryTheory.monoidalOfHasFiniteProducts
code: /-- A category with a terminal object and binary products has a natural monoidal structure. -/
def monoidalOfHasFiniteProducts [HasTerminal C] [HasBinaryProducts C] : MonoidalCategory C 
goal: CategoryTheory.MonoidalCategory C

full_name: CategoryTheory.monoidalOfHasFiniteProducts.unit_ext
code: @[ext] theorem unit_ext {X : C} (f g : X ⟶ 𝟙_ C) : f = g 
goal: f = g

full_name: CategoryTheory.monoidalOfHasFiniteProducts.tensor_ext
code: @[ext] theorem tensor_ext {X Y Z : C} (f g : X ⟶ Y ⊗ Z)
    (w₁ : f ≫ prod.fst = g ≫ prod.fst) (w₂ : f ≫ prod.snd = g ≫ prod.snd) : f = g 
goal: f = g

full_name: CategoryTheory.monoidalOfHasFiniteProducts.tensorUnit
code: @[simp] theorem tensorUnit : 𝟙_ C = ⊤_ C 
goal: 𝟙_ C = ⊤_ C

full_name: CategoryTheory.monoidalOfHasFiniteProducts.tensorObj
code: @[simp]
theorem tensorObj (X Y : C) : X ⊗ Y = (X ⨯ Y) 
goal: CategoryTheory.MonoidalCategory.tensorObj X Y = (X ⨯ Y)

full_name: CategoryTheory.monoidalOfHasFiniteProducts.tensorHom
code: @[simp]
theorem tensorHom {W X Y Z : C} (f : W ⟶ X) (g : Y ⟶ Z) : f ⊗ g = Limits.prod.map f g 
goal: CategoryTheory.MonoidalCategory.tensorHom f g = CategoryTheory.Limits.prod.map f g

full_name: CategoryTheory.monoidalOfHasFiniteProducts.whiskerLeft
code: @[simp]
theorem whiskerLeft (X : C) {Y Z : C} (f : Y ⟶ Z) : X ◁ f = Limits.prod.map (𝟙 X) f 
goal: CategoryTheory.MonoidalCategory.whiskerLeft X f = CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id X) f

full_name: CategoryTheory.monoidalOfHasFiniteProducts.whiskerRight
code: @[simp]
theorem whiskerRight {X Y : C} (f : X ⟶ Y) (Z : C) : f ▷ Z = Limits.prod.map f (𝟙 Z) 
goal: CategoryTheory.MonoidalCategory.whiskerRight f Z = CategoryTheory.Limits.prod.map f (CategoryTheory.CategoryStruct.id Z)

full_name: CategoryTheory.monoidalOfHasFiniteProducts.leftUnitor_hom
code: @[simp]
theorem leftUnitor_hom (X : C) : (λ_ X).hom = Limits.prod.snd 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).hom = CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.monoidalOfHasFiniteProducts.leftUnitor_inv
code: @[simp]
theorem leftUnitor_inv (X : C) : (λ_ X).inv = prod.lift (terminal.from X) (𝟙 _) 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).inv =
  CategoryTheory.Limits.prod.lift (CategoryTheory.Limits.terminal.from X) (CategoryTheory.CategoryStruct.id X)

full_name: CategoryTheory.monoidalOfHasFiniteProducts.rightUnitor_hom
code: @[simp]
theorem rightUnitor_hom (X : C) : (ρ_ X).hom = Limits.prod.fst 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).hom = CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.monoidalOfHasFiniteProducts.rightUnitor_inv
code: @[simp]
theorem rightUnitor_inv (X : C) : (ρ_ X).inv = prod.lift (𝟙 _) (terminal.from X) 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).inv =
  CategoryTheory.Limits.prod.lift (CategoryTheory.CategoryStruct.id X) (CategoryTheory.Limits.terminal.from X)

full_name: CategoryTheory.monoidalOfHasFiniteProducts.associator_hom
code: theorem associator_hom (X Y Z : C) :
    (α_ X Y Z).hom =
      prod.lift (Limits.prod.fst ≫ Limits.prod.fst)
        (prod.lift (Limits.prod.fst ≫ Limits.prod.snd) Limits.prod.snd) 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).hom =
  CategoryTheory.Limits.prod.lift
    (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.fst)
    (CategoryTheory.Limits.prod.lift
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.snd)
      CategoryTheory.Limits.prod.snd)

full_name: CategoryTheory.monoidalOfHasFiniteProducts.associator_inv
code: theorem associator_inv (X Y Z : C) :
    (α_ X Y Z).inv =
      prod.lift (prod.lift prod.fst (prod.snd ≫ prod.fst)) (prod.snd ≫ prod.snd) 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).inv =
  CategoryTheory.Limits.prod.lift
    (CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.fst
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst))
    (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd)

full_name: CategoryTheory.monoidalOfHasFiniteProducts.associator_hom_fst
code: @[reassoc] theorem associator_hom_fst (X Y Z : C) :
    (α_ X Y Z).hom ≫ prod.fst = prod.fst ≫ prod.fst 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Y Z).hom
    CategoryTheory.Limits.prod.fst =
  CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.monoidalOfHasFiniteProducts.associator_hom_snd_fst
code: @[reassoc] theorem associator_hom_snd_fst (X Y Z : C) :
    (α_ X Y Z).hom ≫ prod.snd ≫ prod.fst = prod.fst ≫ prod.snd 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Y Z).hom
    (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst) =
  CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.monoidalOfHasFiniteProducts.associator_hom_snd_snd
code: @[reassoc] theorem associator_hom_snd_snd (X Y Z : C) :
    (α_ X Y Z).hom ≫ prod.snd ≫ prod.snd = prod.snd 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Y Z).hom
    (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd) =
  CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.monoidalOfHasFiniteProducts.associator_inv_fst_fst
code: @[reassoc] theorem associator_inv_fst_fst (X Y Z : C) :
    (α_ X Y Z).inv ≫ prod.fst ≫ prod.fst = prod.fst 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Y Z).inv
    (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.fst) =
  CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.monoidalOfHasFiniteProducts.associator_inv_fst_snd
code: @[reassoc] theorem associator_inv_fst_snd (X Y Z : C) :
    (α_ X Y Z).inv ≫ prod.fst ≫ prod.snd = prod.snd ≫ prod.fst 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Y Z).inv
    (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.snd) =
  CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.monoidalOfHasFiniteProducts.associator_inv_snd
code: @[reassoc] theorem associator_inv_snd (X Y Z : C) :
    (α_ X Y Z).inv ≫ prod.snd = prod.snd ≫ prod.snd 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Y Z).inv
    CategoryTheory.Limits.prod.snd =
  CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.symmetricOfHasFiniteProducts
code: /-- The monoidal structure coming from finite products is symmetric.
-/
@[simps]
def symmetricOfHasFiniteProducts [HasTerminal C] [HasBinaryProducts C] : SymmetricCategory C 
goal: CategoryTheory.SymmetricCategory C

full_name: CategoryTheory.symmetricOfHasFiniteProducts_braiding
code: /-- The monoidal structure coming from finite products is symmetric.
-/
@[simps]
def symmetricOfHasFiniteProducts [HasTerminal C] [HasBinaryProducts C] : SymmetricCategory C 
goal: β_ X Y = CategoryTheory.Limits.prod.braiding X Y

full_name: CategoryTheory.monoidalOfHasFiniteCoproducts
code: /-- A category with an initial object and binary coproducts has a natural monoidal structure. -/
def monoidalOfHasFiniteCoproducts [HasInitial C] [HasBinaryCoproducts C] : MonoidalCategory C 
goal: CategoryTheory.MonoidalCategory C

full_name: CategoryTheory.monoidalOfHasFiniteCoproducts.tensorObj
code: @[simp]
theorem tensorObj (X Y : C) : X ⊗ Y = (X ⨿ Y) 
goal: CategoryTheory.MonoidalCategory.tensorObj X Y = (X ⨿ Y)

full_name: CategoryTheory.monoidalOfHasFiniteCoproducts.tensorHom
code: @[simp]
theorem tensorHom {W X Y Z : C} (f : W ⟶ X) (g : Y ⟶ Z) : f ⊗ g = Limits.coprod.map f g 
goal: CategoryTheory.MonoidalCategory.tensorHom f g = CategoryTheory.Limits.coprod.map f g

full_name: CategoryTheory.monoidalOfHasFiniteCoproducts.whiskerLeft
code: @[simp]
theorem whiskerLeft (X : C) {Y Z : C} (f : Y ⟶ Z) : X ◁ f = Limits.coprod.map (𝟙 X) f 
goal: CategoryTheory.MonoidalCategory.whiskerLeft X f =
  CategoryTheory.Limits.coprod.map (CategoryTheory.CategoryStruct.id X) f

full_name: CategoryTheory.monoidalOfHasFiniteCoproducts.whiskerRight
code: @[simp]
theorem whiskerRight {X Y : C} (f : X ⟶ Y) (Z : C) : f ▷ Z = Limits.coprod.map f (𝟙 Z) 
goal: CategoryTheory.MonoidalCategory.whiskerRight f Z =
  CategoryTheory.Limits.coprod.map f (CategoryTheory.CategoryStruct.id Z)

full_name: CategoryTheory.monoidalOfHasFiniteCoproducts.leftUnitor_hom
code: @[simp]
theorem leftUnitor_hom (X : C) : (λ_ X).hom = coprod.desc (initial.to X) (𝟙 _) 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).hom =
  CategoryTheory.Limits.coprod.desc (CategoryTheory.Limits.initial.to X) (CategoryTheory.CategoryStruct.id X)

full_name: CategoryTheory.monoidalOfHasFiniteCoproducts.rightUnitor_hom
code: @[simp]
theorem rightUnitor_hom (X : C) : (ρ_ X).hom = coprod.desc (𝟙 _) (initial.to X) 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).hom =
  CategoryTheory.Limits.coprod.desc (CategoryTheory.CategoryStruct.id X) (CategoryTheory.Limits.initial.to X)

full_name: CategoryTheory.monoidalOfHasFiniteCoproducts.leftUnitor_inv
code: @[simp]
theorem leftUnitor_inv (X : C) : (λ_ X).inv = Limits.coprod.inr 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).inv = CategoryTheory.Limits.coprod.inr

full_name: CategoryTheory.monoidalOfHasFiniteCoproducts.rightUnitor_inv
code: @[simp]
theorem rightUnitor_inv (X : C) : (ρ_ X).inv = Limits.coprod.inl 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).inv = CategoryTheory.Limits.coprod.inl

full_name: CategoryTheory.monoidalOfHasFiniteCoproducts.associator_hom
code: theorem associator_hom (X Y Z : C) :
    (α_ X Y Z).hom =
      coprod.desc (coprod.desc coprod.inl (coprod.inl ≫ coprod.inr)) (coprod.inr ≫ coprod.inr) 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).hom =
  CategoryTheory.Limits.coprod.desc
    (CategoryTheory.Limits.coprod.desc CategoryTheory.Limits.coprod.inl
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl CategoryTheory.Limits.coprod.inr))
    (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inr CategoryTheory.Limits.coprod.inr)

full_name: CategoryTheory.monoidalOfHasFiniteCoproducts.associator_inv
code: theorem associator_inv (X Y Z : C) :
    (α_ X Y Z).inv =
      coprod.desc (coprod.inl ≫ coprod.inl) (coprod.desc (coprod.inr ≫ coprod.inl) coprod.inr) 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).inv =
  CategoryTheory.Limits.coprod.desc
    (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl CategoryTheory.Limits.coprod.inl)
    (CategoryTheory.Limits.coprod.desc
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inr CategoryTheory.Limits.coprod.inl)
      CategoryTheory.Limits.coprod.inr)

full_name: CategoryTheory.symmetricOfHasFiniteCoproducts
code: /-- The monoidal structure coming from finite coproducts is symmetric.
-/
@[simps]
def symmetricOfHasFiniteCoproducts [HasInitial C] [HasBinaryCoproducts C] :
    SymmetricCategory C 
goal: CategoryTheory.SymmetricCategory C

full_name: CategoryTheory.symmetricOfHasFiniteCoproducts_braiding
code: /-- The monoidal structure coming from finite coproducts is symmetric.
-/
@[simps]
def symmetricOfHasFiniteCoproducts [HasInitial C] [HasBinaryCoproducts C] :
    SymmetricCategory C 
goal: β_ P Q = CategoryTheory.Limits.coprod.braiding P Q

full_name: CategoryTheory.Functor.toMonoidalFunctorOfHasFiniteProducts_toLaxMonoidalFunctor_μ
code: /-- Promote a finite products preserving functor to a monoidal functor between
categories equipped with the monoidal category structure given by finite products. -/
@[simps]
def Functor.toMonoidalFunctorOfHasFiniteProducts : MonoidalFunctor C D 
goal: F.toMonoidalFunctorOfHasFiniteProducts.μ X Y = (CategoryTheory.asIso (CategoryTheory.Limits.prodComparison F X Y)).inv

full_name: CategoryTheory.Functor.toMonoidalFunctorOfHasFiniteProducts_toLaxMonoidalFunctor_toFunctor
code: /-- Promote a finite products preserving functor to a monoidal functor between
categories equipped with the monoidal category structure given by finite products. -/
@[simps]
def Functor.toMonoidalFunctorOfHasFiniteProducts : MonoidalFunctor C D 
goal: F.toMonoidalFunctorOfHasFiniteProducts.toFunctor = F

full_name: CategoryTheory.Functor.toMonoidalFunctorOfHasFiniteProducts_toLaxMonoidalFunctor_ε
code: /-- Promote a finite products preserving functor to a monoidal functor between
categories equipped with the monoidal category structure given by finite products. -/
@[simps]
def Functor.toMonoidalFunctorOfHasFiniteProducts : MonoidalFunctor C D 
goal: F.toMonoidalFunctorOfHasFiniteProducts.ε = (CategoryTheory.asIso (CategoryTheory.Limits.terminalComparison F)).inv

full_name: CategoryTheory.Functor.toMonoidalFunctorOfHasFiniteProducts
code: /-- Promote a finite products preserving functor to a monoidal functor between
categories equipped with the monoidal category structure given by finite products. -/
@[simps]
def Functor.toMonoidalFunctorOfHasFiniteProducts : MonoidalFunctor C D 
goal: CategoryTheory.MonoidalFunctor C D

full_name: CategoryTheory.instIsEquivalenceToMonoidalFunctorOfHasFiniteProducts
code: instance [F.IsEquivalence] : F.toMonoidalFunctorOfHasFiniteProducts.IsEquivalence 
goal: F.toMonoidalFunctorOfHasFiniteProducts.IsEquivalence