File: Mathlib/CategoryTheory/Dialectica/Monoidal.lean

full_name: CategoryTheory.Dial._aux_Mathlib_CategoryTheory_Dialectica_Monoidal___macroRules_CategoryTheory_Dial_termπ₁_1
code: local notation "π₁" => prod.fst
goal: Lean.Macro

full_name: CategoryTheory.Dial._aux_Mathlib_CategoryTheory_Dialectica_Monoidal___unexpand_CategoryTheory_Limits_prod_fst_1
code: local notation "π₁" => prod.fst
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.Dial._aux_Mathlib_CategoryTheory_Dialectica_Monoidal___unexpand_CategoryTheory_Limits_prod_snd_1
code: local notation "π₂" => prod.snd
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.Dial._aux_Mathlib_CategoryTheory_Dialectica_Monoidal___macroRules_CategoryTheory_Dial_termπ₂_1
code: local notation "π₂" => prod.snd
goal: Lean.Macro

full_name: CategoryTheory.Dial.«_aux_Mathlib_CategoryTheory_Dialectica_Monoidal___macroRules_CategoryTheory_Dial_termπ(_,_)_1»
code: local notation "π(" a ", " b ")" => prod.lift a b
goal: Lean.Macro

full_name: CategoryTheory.Dial._aux_Mathlib_CategoryTheory_Dialectica_Monoidal___unexpand_CategoryTheory_Limits_prod_lift_1
code: local notation "π(" a ", " b ")" => prod.lift a b
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.Dial.tensorObj_src
code: /-- The object `X ⊗ Y` in the `Dial C` category just tuples the left and right components. -/
@[simps] def tensorObj (X Y : Dial C) : Dial C 
goal: (X.tensorObj Y).src = (X.src ⨯ Y.src)

full_name: CategoryTheory.Dial.tensorObj_tgt
code: /-- The object `X ⊗ Y` in the `Dial C` category just tuples the left and right components. -/
@[simps] def tensorObj (X Y : Dial C) : Dial C 
goal: (X.tensorObj Y).tgt = (X.tgt ⨯ Y.tgt)

full_name: CategoryTheory.Dial.tensorObj_rel
code: /-- The object `X ⊗ Y` in the `Dial C` category just tuples the left and right components. -/
@[simps] def tensorObj (X Y : Dial C) : Dial C 
goal: (X.tensorObj Y).rel =
  (CategoryTheory.Subobject.pullback
          (CategoryTheory.Limits.prod.map CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.fst)).obj
      X.rel ⊓
    (CategoryTheory.Subobject.pullback
          (CategoryTheory.Limits.prod.map CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd)).obj
      Y.rel

full_name: CategoryTheory.Dial.tensorObj
code: /-- The object `X ⊗ Y` in the `Dial C` category just tuples the left and right components. -/
@[simps] def tensorObj (X Y : Dial C) : Dial C 
goal: CategoryTheory.Dial C

full_name: CategoryTheory.Dial.tensorHom_F
code: /-- The functorial action of `X ⊗ Y` in `Dial C`. -/
@[simps] def tensorHom {X₁ X₂ Y₁ Y₂ : Dial C} (f : X₁ ⟶ X₂) (g : Y₁ ⟶ Y₂) :
    tensorObj X₁ Y₁ ⟶ tensorObj X₂ Y₂ 
goal: (CategoryTheory.Dial.tensorHom f g).F =
  CategoryTheory.Limits.prod.lift
    (CategoryTheory.CategoryStruct.comp
      (CategoryTheory.Limits.prod.map CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.fst) f.F)
    (CategoryTheory.CategoryStruct.comp
      (CategoryTheory.Limits.prod.map CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd) g.F)

full_name: CategoryTheory.Dial.tensorHom_f
code: /-- The functorial action of `X ⊗ Y` in `Dial C`. -/
@[simps] def tensorHom {X₁ X₂ Y₁ Y₂ : Dial C} (f : X₁ ⟶ X₂) (g : Y₁ ⟶ Y₂) :
    tensorObj X₁ Y₁ ⟶ tensorObj X₂ Y₂ 
goal: (CategoryTheory.Dial.tensorHom f g).f = CategoryTheory.Limits.prod.map f.f g.f

full_name: CategoryTheory.Dial.tensorHom
code: /-- The functorial action of `X ⊗ Y` in `Dial C`. -/
@[simps] def tensorHom {X₁ X₂ Y₁ Y₂ : Dial C} (f : X₁ ⟶ X₂) (g : Y₁ ⟶ Y₂) :
    tensorObj X₁ Y₁ ⟶ tensorObj X₂ Y₂ 
goal: X₁.tensorObj Y₁ ⟶ X₂.tensorObj Y₂

full_name: CategoryTheory.Dial.tensorUnit
code: /-- The unit for the tensor `X ⊗ Y` in `Dial C`. -/
@[simps] def tensorUnit : Dial C 
goal: CategoryTheory.Dial C

full_name: CategoryTheory.Dial.tensorUnit_rel
code: /-- The unit for the tensor `X ⊗ Y` in `Dial C`. -/
@[simps] def tensorUnit : Dial C 
goal: CategoryTheory.Dial.tensorUnit.rel = ⊤

full_name: CategoryTheory.Dial.tensorUnit_src
code: /-- The unit for the tensor `X ⊗ Y` in `Dial C`. -/
@[simps] def tensorUnit : Dial C 
goal: CategoryTheory.Dial.tensorUnit.src = ⊤_ C

full_name: CategoryTheory.Dial.tensorUnit_tgt
code: /-- The unit for the tensor `X ⊗ Y` in `Dial C`. -/
@[simps] def tensorUnit : Dial C 
goal: CategoryTheory.Dial.tensorUnit.tgt = ⊤_ C

full_name: CategoryTheory.Dial.leftUnitor_hom_F
code: /-- Left unit cancellation `1 ⊗ X ≅ X` in `Dial C`. -/
@[simps!] def leftUnitor (X : Dial C) : tensorObj tensorUnit X ≅ X 
goal: X.leftUnitor.hom.F =
  CategoryTheory.Limits.prod.lift (CategoryTheory.Limits.terminal.from (((⊤_ C) ⨯ X.src) ⨯ X.tgt))
    CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.Dial.leftUnitor
code: /-- Left unit cancellation `1 ⊗ X ≅ X` in `Dial C`. -/
@[simps!] def leftUnitor (X : Dial C) : tensorObj tensorUnit X ≅ X 
goal: CategoryTheory.Dial.tensorUnit.tensorObj X ≅ X

full_name: CategoryTheory.Dial.leftUnitor_inv_F
code: /-- Left unit cancellation `1 ⊗ X ≅ X` in `Dial C`. -/
@[simps!] def leftUnitor (X : Dial C) : tensorObj tensorUnit X ≅ X 
goal: X.leftUnitor.inv.F = CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.Dial.leftUnitor_inv_f
code: /-- Left unit cancellation `1 ⊗ X ≅ X` in `Dial C`. -/
@[simps!] def leftUnitor (X : Dial C) : tensorObj tensorUnit X ≅ X 
goal: X.leftUnitor.inv.f =
  CategoryTheory.Limits.prod.lift (CategoryTheory.Limits.terminal.from X.src) (CategoryTheory.CategoryStruct.id X.src)

full_name: CategoryTheory.Dial.leftUnitor_hom_f
code: /-- Left unit cancellation `1 ⊗ X ≅ X` in `Dial C`. -/
@[simps!] def leftUnitor (X : Dial C) : tensorObj tensorUnit X ≅ X 
goal: X.leftUnitor.hom.f = CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.Dial.rightUnitor
code: /-- Right unit cancellation `X ⊗ 1 ≅ X` in `Dial C`. -/
@[simps!] def rightUnitor (X : Dial C) : tensorObj X tensorUnit ≅ X 
goal: X.tensorObj CategoryTheory.Dial.tensorUnit ≅ X

full_name: CategoryTheory.Dial.rightUnitor_hom_F
code: /-- Right unit cancellation `X ⊗ 1 ≅ X` in `Dial C`. -/
@[simps!] def rightUnitor (X : Dial C) : tensorObj X tensorUnit ≅ X 
goal: X.rightUnitor.hom.F =
  CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.snd
    (CategoryTheory.Limits.terminal.from ((X.src ⨯ ⊤_ C) ⨯ X.tgt))

full_name: CategoryTheory.Dial.rightUnitor_hom_f
code: /-- Right unit cancellation `X ⊗ 1 ≅ X` in `Dial C`. -/
@[simps!] def rightUnitor (X : Dial C) : tensorObj X tensorUnit ≅ X 
goal: X.rightUnitor.hom.f = CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.Dial.rightUnitor_inv_F
code: /-- Right unit cancellation `X ⊗ 1 ≅ X` in `Dial C`. -/
@[simps!] def rightUnitor (X : Dial C) : tensorObj X tensorUnit ≅ X 
goal: X.rightUnitor.inv.F = CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.Dial.rightUnitor_inv_f
code: /-- Right unit cancellation `X ⊗ 1 ≅ X` in `Dial C`. -/
@[simps!] def rightUnitor (X : Dial C) : tensorObj X tensorUnit ≅ X 
goal: X.rightUnitor.inv.f =
  CategoryTheory.Limits.prod.lift (CategoryTheory.CategoryStruct.id X.src) (CategoryTheory.Limits.terminal.from X.src)

full_name: CategoryTheory.Dial.associator
code: /-- The associator for tensor, `(X ⊗ Y) ⊗ Z ≅ X ⊗ (Y ⊗ Z)` in `Dial C`. -/
@[simps!]
def associator (X Y Z : Dial C) : tensorObj (tensorObj X Y) Z ≅ tensorObj X (tensorObj Y Z) 
goal: (X.tensorObj Y).tensorObj Z ≅ X.tensorObj (Y.tensorObj Z)

full_name: CategoryTheory.Dial.associator_inv_F
code: /-- The associator for tensor, `(X ⊗ Y) ⊗ Z ≅ X ⊗ (Y ⊗ Z)` in `Dial C`. -/
@[simps!]
def associator (X Y Z : Dial C) : tensorObj (tensorObj X Y) Z ≅ tensorObj X (tensorObj Y Z) 
goal: (X.associator Y Z).inv.F =
  CategoryTheory.Limits.prod.lift
    (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.fst))
    (CategoryTheory.Limits.prod.lift
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd
        (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.snd))
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd))

full_name: CategoryTheory.Dial.associator_hom_F
code: /-- The associator for tensor, `(X ⊗ Y) ⊗ Z ≅ X ⊗ (Y ⊗ Z)` in `Dial C`. -/
@[simps!]
def associator (X Y Z : Dial C) : tensorObj (tensorObj X Y) Z ≅ tensorObj X (tensorObj Y Z) 
goal: (X.associator Y Z).hom.F =
  CategoryTheory.Limits.prod.lift
    (CategoryTheory.Limits.prod.lift
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst)
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd
        (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst)))
    (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd))

full_name: CategoryTheory.Dial.associator_hom_f
code: /-- The associator for tensor, `(X ⊗ Y) ⊗ Z ≅ X ⊗ (Y ⊗ Z)` in `Dial C`. -/
@[simps!]
def associator (X Y Z : Dial C) : tensorObj (tensorObj X Y) Z ≅ tensorObj X (tensorObj Y Z) 
goal: (X.associator Y Z).hom.f =
  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.Dial.associator_inv_f
code: /-- The associator for tensor, `(X ⊗ Y) ⊗ Z ≅ X ⊗ (Y ⊗ Z)` in `Dial C`. -/
@[simps!]
def associator (X Y Z : Dial C) : tensorObj (tensorObj X Y) Z ≅ tensorObj X (tensorObj Y Z) 
goal: (X.associator Y Z).inv.f =
  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.Dial.instMonoidalCategoryStruct_leftUnitor_hom_F
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).hom.F =
  CategoryTheory.Limits.prod.lift (CategoryTheory.Limits.terminal.from (((⊤_ C) ⨯ X.src) ⨯ X.tgt))
    CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_leftUnitor_inv_F
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).inv.F =
  CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_tensorUnit_tgt
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (𝟙_ (CategoryTheory.Dial C)).tgt = ⊤_ C

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_tensorHom_f
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: ∀ {X₁ Y₁ X₂ Y₂ : CategoryTheory.Dial C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
  (CategoryTheory.MonoidalCategory.tensorHom f g).f = CategoryTheory.Limits.prod.map f.f g.f

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_leftUnitor_inv_f
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).inv.f =
  CategoryTheory.Limits.prod.lift (CategoryTheory.Limits.terminal.from X.src) (CategoryTheory.CategoryStruct.id X.src)

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_rightUnitor_hom_F
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).hom.F =
  CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.snd
    (CategoryTheory.Limits.terminal.from ((X.src ⨯ ⊤_ C) ⨯ X.tgt))

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_associator_hom_F
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).hom.F =
  CategoryTheory.Limits.prod.lift
    (CategoryTheory.Limits.prod.lift
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst)
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd
        (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst)))
    (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd))

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_tensorObj_tgt
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (CategoryTheory.MonoidalCategory.tensorObj X Y).tgt = (X.tgt ⨯ Y.tgt)

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_associator_hom_f
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).hom.f =
  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.Dial.instMonoidalCategoryStruct_rightUnitor_inv_F
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).inv.F =
  CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_tensorObj_src
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (CategoryTheory.MonoidalCategory.tensorObj X Y).src = (X.src ⨯ Y.src)

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_tensorUnit_src
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (𝟙_ (CategoryTheory.Dial C)).src = ⊤_ C

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_whiskerRight_F
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: ∀ {X₁ X₂ : CategoryTheory.Dial C} (f : X₁ ⟶ X₂) (Y : CategoryTheory.Dial C),
  (CategoryTheory.MonoidalCategory.whiskerRight f Y).F =
    CategoryTheory.Limits.prod.lift
      (CategoryTheory.CategoryStruct.comp
        (CategoryTheory.Limits.prod.map CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.fst) f.F)
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd)

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_whiskerLeft_f
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: ∀ (x x_1 : CategoryTheory.Dial C) (f : x ⟶ x_1),
  (CategoryTheory.MonoidalCategory.whiskerLeft X f).f =
    CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id X.src) f.f

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_associator_inv_f
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).inv.f =
  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.Dial.instMonoidalCategoryStruct
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: CategoryTheory.MonoidalCategoryStruct (CategoryTheory.Dial C)

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_whiskerLeft_F
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: ∀ (x x_1 : CategoryTheory.Dial C) (f : x ⟶ x_1),
  (CategoryTheory.MonoidalCategory.whiskerLeft X f).F =
    CategoryTheory.Limits.prod.lift
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst)
      (CategoryTheory.CategoryStruct.comp
        (CategoryTheory.Limits.prod.map CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd) f.F)

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_whiskerRight_f
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: ∀ {X₁ X₂ : CategoryTheory.Dial C} (f : X₁ ⟶ X₂) (Y : CategoryTheory.Dial C),
  (CategoryTheory.MonoidalCategory.whiskerRight f Y).f =
    CategoryTheory.Limits.prod.map f.f (CategoryTheory.CategoryStruct.id Y.src)

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_tensorUnit_rel
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (𝟙_ (CategoryTheory.Dial C)).rel = ⊤

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_tensorObj_rel
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (CategoryTheory.MonoidalCategory.tensorObj X Y).rel =
  (CategoryTheory.Subobject.pullback
          (CategoryTheory.Limits.prod.map CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.fst)).obj
      X.rel ⊓
    (CategoryTheory.Subobject.pullback
          (CategoryTheory.Limits.prod.map CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd)).obj
      Y.rel

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_tensorHom_F
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: ∀ {X₁ Y₁ X₂ Y₂ : CategoryTheory.Dial C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
  (CategoryTheory.MonoidalCategory.tensorHom f g).F =
    CategoryTheory.Limits.prod.lift
      (CategoryTheory.CategoryStruct.comp
        (CategoryTheory.Limits.prod.map CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.fst) f.F)
      (CategoryTheory.CategoryStruct.comp
        (CategoryTheory.Limits.prod.map CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd) g.F)

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_leftUnitor_hom_f
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (CategoryTheory.MonoidalCategory.leftUnitor X).hom.f = CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_rightUnitor_inv_f
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).inv.f =
  CategoryTheory.Limits.prod.lift (CategoryTheory.CategoryStruct.id X.src) (CategoryTheory.Limits.terminal.from X.src)

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_associator_inv_F
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (CategoryTheory.MonoidalCategory.associator X Y Z).inv.F =
  CategoryTheory.Limits.prod.lift
    (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.fst))
    (CategoryTheory.Limits.prod.lift
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd
        (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.snd))
      (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd))

full_name: CategoryTheory.Dial.instMonoidalCategoryStruct_rightUnitor_hom_f
code: @[simps!]
instance : MonoidalCategoryStruct (Dial C) 
goal: (CategoryTheory.MonoidalCategory.rightUnitor X).hom.f = CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.Dial.tensor_id
code: theorem tensor_id (X₁ X₂ : Dial C) : (𝟙 X₁ ⊗ 𝟙 X₂ : _ ⟶ _) = 𝟙 (X₁ ⊗ X₂ : Dial C) 
goal: CategoryTheory.MonoidalCategory.tensorHom (CategoryTheory.CategoryStruct.id X₁) (CategoryTheory.CategoryStruct.id X₂) =
  CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategory.tensorObj X₁ X₂)

full_name: CategoryTheory.Dial.tensor_comp
code: theorem tensor_comp {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : Dial C}
    (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (g₁ : Y₁ ⟶ Z₁) (g₂ : Y₂ ⟶ Z₂) :
    tensorHom (f₁ ≫ g₁) (f₂ ≫ g₂) = tensorHom f₁ f₂ ≫ tensorHom g₁ g₂ 
goal: CategoryTheory.Dial.tensorHom (CategoryTheory.CategoryStruct.comp f₁ g₁) (CategoryTheory.CategoryStruct.comp f₂ g₂) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Dial.tensorHom f₁ f₂) (CategoryTheory.Dial.tensorHom g₁ g₂)

full_name: CategoryTheory.Dial.associator_naturality
code: theorem associator_naturality {X₁ X₂ X₃ Y₁ Y₂ Y₃ : Dial C}
    (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃ : X₃ ⟶ Y₃) :
    tensorHom (tensorHom f₁ f₂) f₃ ≫ (associator Y₁ Y₂ Y₃).hom =
    (associator X₁ X₂ X₃).hom ≫ tensorHom f₁ (tensorHom f₂ f₃) 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Dial.tensorHom (CategoryTheory.Dial.tensorHom f₁ f₂) f₃)
    (Y₁.associator Y₂ Y₃).hom =
  CategoryTheory.CategoryStruct.comp (X₁.associator X₂ X₃).hom
    (CategoryTheory.Dial.tensorHom f₁ (CategoryTheory.Dial.tensorHom f₂ f₃))

full_name: CategoryTheory.Dial.leftUnitor_naturality
code: theorem leftUnitor_naturality {X Y : Dial C} (f : X ⟶ Y) :
    (𝟙 (𝟙_ (Dial C)) ⊗ f) ≫ (λ_ Y).hom = (λ_ X).hom ≫ f 
goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.MonoidalCategory.tensorHom (CategoryTheory.CategoryStruct.id (𝟙_ (CategoryTheory.Dial C))) f)
    (CategoryTheory.MonoidalCategory.leftUnitor Y).hom =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.leftUnitor X).hom f

full_name: CategoryTheory.Dial.rightUnitor_naturality
code: theorem rightUnitor_naturality {X Y : Dial C} (f : X ⟶ Y) :
    (f ⊗ 𝟙 (𝟙_ (Dial C))) ≫ (ρ_ Y).hom = (ρ_ X).hom ≫ f 
goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.MonoidalCategory.tensorHom f (CategoryTheory.CategoryStruct.id (𝟙_ (CategoryTheory.Dial C))))
    (CategoryTheory.MonoidalCategory.rightUnitor Y).hom =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.rightUnitor X).hom f

full_name: CategoryTheory.Dial.pentagon
code: theorem pentagon (W X Y Z : Dial C) :
    (tensorHom (associator W X Y).hom (𝟙 Z)) ≫ (associator W (tensorObj X Y) Z).hom ≫
      (tensorHom (𝟙 W) (associator X Y Z).hom) =
    (associator (tensorObj W X) Y Z).hom ≫ (associator W X (tensorObj Y Z)).hom 
goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Dial.tensorHom (W.associator X Y).hom (CategoryTheory.CategoryStruct.id Z))
    (CategoryTheory.CategoryStruct.comp (W.associator (X.tensorObj Y) Z).hom
      (CategoryTheory.Dial.tensorHom (CategoryTheory.CategoryStruct.id W) (X.associator Y Z).hom)) =
  CategoryTheory.CategoryStruct.comp ((W.tensorObj X).associator Y Z).hom (W.associator X (Y.tensorObj Z)).hom

full_name: CategoryTheory.Dial.triangle
code: theorem triangle (X Y : Dial C) :
    (associator X (𝟙_ (Dial C)) Y).hom ≫ tensorHom (𝟙 X) (leftUnitor Y).hom =
    tensorHom (rightUnitor X).hom (𝟙 Y) 
goal: CategoryTheory.CategoryStruct.comp (X.associator (𝟙_ (CategoryTheory.Dial C)) Y).hom
    (CategoryTheory.Dial.tensorHom (CategoryTheory.CategoryStruct.id X) Y.leftUnitor.hom) =
  CategoryTheory.Dial.tensorHom X.rightUnitor.hom (CategoryTheory.CategoryStruct.id Y)

full_name: CategoryTheory.Dial.instMonoidalCategory
code: instance : MonoidalCategory (Dial C) 
goal: CategoryTheory.MonoidalCategory (CategoryTheory.Dial C)

full_name: CategoryTheory.Dial.braiding_hom_F
code: /-- The braiding isomorphism `X ⊗ Y ≅ Y ⊗ X` in `Dial C`. -/
@[simps!] def braiding (X Y : Dial C) : tensorObj X Y ≅ tensorObj Y X 
goal: (X.braiding Y).hom.F =
  CategoryTheory.Limits.prod.lift
    (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd)
    (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst)

full_name: CategoryTheory.Dial.braiding
code: /-- The braiding isomorphism `X ⊗ Y ≅ Y ⊗ X` in `Dial C`. -/
@[simps!] def braiding (X Y : Dial C) : tensorObj X Y ≅ tensorObj Y X 
goal: X.tensorObj Y ≅ Y.tensorObj X

full_name: CategoryTheory.Dial.braiding_hom_f
code: /-- The braiding isomorphism `X ⊗ Y ≅ Y ⊗ X` in `Dial C`. -/
@[simps!] def braiding (X Y : Dial C) : tensorObj X Y ≅ tensorObj Y X 
goal: (X.braiding Y).hom.f = CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.Dial.braiding_inv_F
code: /-- The braiding isomorphism `X ⊗ Y ≅ Y ⊗ X` in `Dial C`. -/
@[simps!] def braiding (X Y : Dial C) : tensorObj X Y ≅ tensorObj Y X 
goal: (X.braiding Y).inv.F =
  CategoryTheory.Limits.prod.lift
    (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd)
    (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst)

full_name: CategoryTheory.Dial.braiding_inv_f
code: /-- The braiding isomorphism `X ⊗ Y ≅ Y ⊗ X` in `Dial C`. -/
@[simps!] def braiding (X Y : Dial C) : tensorObj X Y ≅ tensorObj Y X 
goal: (X.braiding Y).inv.f = CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.Dial.symmetry
code: theorem symmetry (X Y : Dial C) :
    (braiding X Y).hom ≫ (braiding Y X).hom = 𝟙 (tensorObj X Y) 
goal: CategoryTheory.CategoryStruct.comp (X.braiding Y).hom (Y.braiding X).hom =
  CategoryTheory.CategoryStruct.id (X.tensorObj Y)

full_name: CategoryTheory.Dial.braiding_naturality_right
code: theorem braiding_naturality_right (X : Dial C) {Y Z : Dial C} (f : Y ⟶ Z) :
    tensorHom (𝟙 X) f ≫ (braiding X Z).hom = (braiding X Y).hom ≫ tensorHom f (𝟙 X) 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Dial.tensorHom (CategoryTheory.CategoryStruct.id X) f)
    (X.braiding Z).hom =
  CategoryTheory.CategoryStruct.comp (X.braiding Y).hom
    (CategoryTheory.Dial.tensorHom f (CategoryTheory.CategoryStruct.id X))

full_name: CategoryTheory.Dial.braiding_naturality_left
code: theorem braiding_naturality_left {X Y : Dial C} (f : X ⟶ Y) (Z : Dial C) :
    tensorHom f (𝟙 Z) ≫ (braiding Y Z).hom = (braiding X Z).hom ≫ tensorHom (𝟙 Z) f 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Dial.tensorHom f (CategoryTheory.CategoryStruct.id Z))
    (Y.braiding Z).hom =
  CategoryTheory.CategoryStruct.comp (X.braiding Z).hom
    (CategoryTheory.Dial.tensorHom (CategoryTheory.CategoryStruct.id Z) f)

full_name: CategoryTheory.Dial.hexagon_forward
code: theorem hexagon_forward (X Y Z : Dial C) :
    (associator X Y Z).hom ≫ (braiding X (Y ⊗ Z)).hom ≫ (associator Y Z X).hom =
      tensorHom (braiding X Y).hom (𝟙 Z) ≫ (associator Y X Z).hom ≫
      tensorHom (𝟙 Y) (braiding X Z).hom 
goal: CategoryTheory.CategoryStruct.comp (X.associator Y Z).hom
    (CategoryTheory.CategoryStruct.comp (X.braiding (CategoryTheory.MonoidalCategory.tensorObj Y Z)).hom
      (Y.associator Z X).hom) =
  CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Dial.tensorHom (X.braiding Y).hom (CategoryTheory.CategoryStruct.id Z))
    (CategoryTheory.CategoryStruct.comp (Y.associator X Z).hom
      (CategoryTheory.Dial.tensorHom (CategoryTheory.CategoryStruct.id Y) (X.braiding Z).hom))

full_name: CategoryTheory.Dial.hexagon_reverse
code: theorem hexagon_reverse (X Y Z : Dial C) :
    (associator X Y Z).inv ≫ (braiding (X ⊗ Y) Z).hom ≫ (associator Z X Y).inv =
      tensorHom (𝟙 X) (braiding Y Z).hom ≫ (associator X Z Y).inv ≫
      tensorHom (braiding X Z).hom (𝟙 Y) 
goal: CategoryTheory.CategoryStruct.comp (X.associator Y Z).inv
    (CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategory.tensorObj X Y).braiding Z).hom
      (Z.associator X Y).inv) =
  CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Dial.tensorHom (CategoryTheory.CategoryStruct.id X) (Y.braiding Z).hom)
    (CategoryTheory.CategoryStruct.comp (X.associator Z Y).inv
      (CategoryTheory.Dial.tensorHom (X.braiding Z).hom (CategoryTheory.CategoryStruct.id Y)))

full_name: CategoryTheory.Dial.instSymmetricCategory
code: instance : SymmetricCategory (Dial C) 
goal: CategoryTheory.SymmetricCategory (CategoryTheory.Dial C)