File: Mathlib/CategoryTheory/Products/Unitor.lean

full_name: CategoryTheory.prod.leftUnitor_obj
code: /-- The left unitor functor `1 × C ⥤ C` -/
@[simps]
def leftUnitor : Discrete (PUnit : Type w) × C ⥤ C 
goal: (CategoryTheory.prod.leftUnitor C).obj X = X.2

full_name: CategoryTheory.prod.leftUnitor_map
code: /-- The left unitor functor `1 × C ⥤ C` -/
@[simps]
def leftUnitor : Discrete (PUnit : Type w) × C ⥤ C 
goal: ∀ {X Y : CategoryTheory.Discrete PUnit.{w + 1} × C} (f : X ⟶ Y), (CategoryTheory.prod.leftUnitor C).map f = f.2

full_name: CategoryTheory.prod.leftUnitor
code: /-- The left unitor functor `1 × C ⥤ C` -/
@[simps]
def leftUnitor : Discrete (PUnit : Type w) × C ⥤ C 
goal: CategoryTheory.Discrete PUnit.{w + 1} × C ⥤ C

full_name: CategoryTheory.prod.rightUnitor_obj
code: /-- The right unitor functor `C × 1 ⥤ C` -/
@[simps]
def rightUnitor : C × Discrete (PUnit : Type w) ⥤ C 
goal: (CategoryTheory.prod.rightUnitor C).obj X = X.1

full_name: CategoryTheory.prod.rightUnitor_map
code: /-- The right unitor functor `C × 1 ⥤ C` -/
@[simps]
def rightUnitor : C × Discrete (PUnit : Type w) ⥤ C 
goal: ∀ {X Y : C × CategoryTheory.Discrete PUnit.{w + 1}} (f : X ⟶ Y), (CategoryTheory.prod.rightUnitor C).map f = f.1

full_name: CategoryTheory.prod.rightUnitor
code: /-- The right unitor functor `C × 1 ⥤ C` -/
@[simps]
def rightUnitor : C × Discrete (PUnit : Type w) ⥤ C 
goal: C × CategoryTheory.Discrete PUnit.{w + 1} ⥤ C

full_name: CategoryTheory.prod.leftInverseUnitor_obj
code: /-- The left inverse unitor `C ⥤ 1 × C` -/
@[simps]
def leftInverseUnitor : C ⥤ Discrete (PUnit : Type w) × C 
goal: (CategoryTheory.prod.leftInverseUnitor C).obj X = ({ as := PUnit.unit }, X)

full_name: CategoryTheory.prod.leftInverseUnitor_map
code: /-- The left inverse unitor `C ⥤ 1 × C` -/
@[simps]
def leftInverseUnitor : C ⥤ Discrete (PUnit : Type w) × C 
goal: ∀ {X Y : C} (f : X ⟶ Y),
  (CategoryTheory.prod.leftInverseUnitor C).map f = (𝟙 ((fun X => ({ as := PUnit.unit }, X)) X).1, f)

full_name: CategoryTheory.prod.leftInverseUnitor
code: /-- The left inverse unitor `C ⥤ 1 × C` -/
@[simps]
def leftInverseUnitor : C ⥤ Discrete (PUnit : Type w) × C 
goal: C ⥤ CategoryTheory.Discrete PUnit.{w + 1} × C

full_name: CategoryTheory.prod.rightInverseUnitor_map
code: /-- The right inverse unitor `C ⥤ C × 1` -/
@[simps]
def rightInverseUnitor : C ⥤ C × Discrete (PUnit : Type w) 
goal: ∀ {X Y : C} (f : X ⟶ Y),
  (CategoryTheory.prod.rightInverseUnitor C).map f = (f, 𝟙 ((fun X => (X, { as := PUnit.unit })) X).2)

full_name: CategoryTheory.prod.rightInverseUnitor
code: /-- The right inverse unitor `C ⥤ C × 1` -/
@[simps]
def rightInverseUnitor : C ⥤ C × Discrete (PUnit : Type w) 
goal: C ⥤ C × CategoryTheory.Discrete PUnit.{w + 1}

full_name: CategoryTheory.prod.rightInverseUnitor_obj
code: /-- The right inverse unitor `C ⥤ C × 1` -/
@[simps]
def rightInverseUnitor : C ⥤ C × Discrete (PUnit : Type w) 
goal: (CategoryTheory.prod.rightInverseUnitor C).obj X = (X, { as := PUnit.unit })

full_name: CategoryTheory.prod.leftUnitorEquivalence
code: /-- The equivalence of categories expressing left unity of products of categories.  -/
@[simps]
def leftUnitorEquivalence : Discrete (PUnit : Type w) × C ≌ C 
goal: CategoryTheory.Discrete PUnit.{w + 1} × C ≌ C

full_name: CategoryTheory.prod.leftUnitorEquivalence_functor
code: /-- The equivalence of categories expressing left unity of products of categories.  -/
@[simps]
def leftUnitorEquivalence : Discrete (PUnit : Type w) × C ≌ C 
goal: (CategoryTheory.prod.leftUnitorEquivalence C).functor = CategoryTheory.prod.leftUnitor C

full_name: CategoryTheory.prod.leftUnitorEquivalence_inverse
code: /-- The equivalence of categories expressing left unity of products of categories.  -/
@[simps]
def leftUnitorEquivalence : Discrete (PUnit : Type w) × C ≌ C 
goal: (CategoryTheory.prod.leftUnitorEquivalence C).inverse = CategoryTheory.prod.leftInverseUnitor C

full_name: CategoryTheory.prod.leftUnitorEquivalence_counitIso
code: /-- The equivalence of categories expressing left unity of products of categories.  -/
@[simps]
def leftUnitorEquivalence : Discrete (PUnit : Type w) × C ≌ C 
goal: (CategoryTheory.prod.leftUnitorEquivalence C).counitIso =
  CategoryTheory.Iso.refl (CategoryTheory.prod.leftInverseUnitor C ⋙ CategoryTheory.prod.leftUnitor C)

full_name: CategoryTheory.prod.leftUnitorEquivalence_unitIso
code: /-- The equivalence of categories expressing left unity of products of categories.  -/
@[simps]
def leftUnitorEquivalence : Discrete (PUnit : Type w) × C ≌ C 
goal: (CategoryTheory.prod.leftUnitorEquivalence C).unitIso =
  CategoryTheory.Iso.refl (𝟭 (CategoryTheory.Discrete PUnit.{w + 1} × C))

full_name: CategoryTheory.prod.rightUnitorEquivalence
code: /-- The equivalence of categories expressing right unity of products of categories.  -/
@[simps]
def rightUnitorEquivalence : C × Discrete (PUnit : Type w) ≌ C 
goal: C × CategoryTheory.Discrete PUnit.{w + 1} ≌ C

full_name: CategoryTheory.prod.rightUnitorEquivalence_unitIso
code: /-- The equivalence of categories expressing right unity of products of categories.  -/
@[simps]
def rightUnitorEquivalence : C × Discrete (PUnit : Type w) ≌ C 
goal: (CategoryTheory.prod.rightUnitorEquivalence C).unitIso =
  CategoryTheory.Iso.refl (𝟭 (C × CategoryTheory.Discrete PUnit.{w + 1}))

full_name: CategoryTheory.prod.rightUnitorEquivalence_counitIso
code: /-- The equivalence of categories expressing right unity of products of categories.  -/
@[simps]
def rightUnitorEquivalence : C × Discrete (PUnit : Type w) ≌ C 
goal: (CategoryTheory.prod.rightUnitorEquivalence C).counitIso =
  CategoryTheory.Iso.refl (CategoryTheory.prod.rightInverseUnitor C ⋙ CategoryTheory.prod.rightUnitor C)

full_name: CategoryTheory.prod.rightUnitorEquivalence_functor
code: /-- The equivalence of categories expressing right unity of products of categories.  -/
@[simps]
def rightUnitorEquivalence : C × Discrete (PUnit : Type w) ≌ C 
goal: (CategoryTheory.prod.rightUnitorEquivalence C).functor = CategoryTheory.prod.rightUnitor C

full_name: CategoryTheory.prod.rightUnitorEquivalence_inverse
code: /-- The equivalence of categories expressing right unity of products of categories.  -/
@[simps]
def rightUnitorEquivalence : C × Discrete (PUnit : Type w) ≌ C 
goal: (CategoryTheory.prod.rightUnitorEquivalence C).inverse = CategoryTheory.prod.rightInverseUnitor C

full_name: CategoryTheory.prod.leftUnitor_isEquivalence
code: instance leftUnitor_isEquivalence : (leftUnitor C).IsEquivalence 
goal: (CategoryTheory.prod.leftUnitor C).IsEquivalence

full_name: CategoryTheory.prod.rightUnitor_isEquivalence
code: instance rightUnitor_isEquivalence : (rightUnitor C).IsEquivalence 
goal: (CategoryTheory.prod.rightUnitor C).IsEquivalence