File: Mathlib/CategoryTheory/Monoidal/Comon_.lean

full_name: Comon_.counit
code: /-- A comonoid object internal to a monoidal category.

When the monoidal category is preadditive, this is also sometimes called a "coalgebra object".
-/
structure Comon_ where
  /-- The underlying object of a comonoid object. -/
  X : C
  /-- The counit of a comonoid object. -/
  counit : X ⟶ 𝟙_ C
  /-- The comultiplication morphism of a comonoid object. -/
  comul : X ⟶ X ⊗ X
  counit_comul : comul ≫ (counit ▷ X) = (λ_ X).inv := by aesop_cat
  comul_counit : comul ≫ (X ◁ counit) = (ρ_ X).inv := by aesop_cat
  comul_assoc : comul ≫ (X ◁ comul) = comul ≫ (comul ▷ X) ≫ (α_ X X X).hom := by aesop_cat
goal: self.X ⟶ 𝟙_ C

full_name: Comon_.comul_assoc
code: /-- A comonoid object internal to a monoidal category.

When the monoidal category is preadditive, this is also sometimes called a "coalgebra object".
-/
structure Comon_ where
  /-- The underlying object of a comonoid object. -/
  X : C
  /-- The counit of a comonoid object. -/
  counit : X ⟶ 𝟙_ C
  /-- The comultiplication morphism of a comonoid object. -/
  comul : X ⟶ X ⊗ X
  counit_comul : comul ≫ (counit ▷ X) = (λ_ X).inv := by aesop_cat
  comul_counit : comul ≫ (X ◁ counit) = (ρ_ X).inv := by aesop_cat
  comul_assoc : comul ≫ (X ◁ comul) = comul ≫ (comul ▷ X) ≫ (α_ X X X).hom := by aesop_cat
goal: self.comul ≫ self.X ◁ self.comul = self.comul ≫ self.comul ▷ self.X ≫ (α_ self.X self.X self.X).hom

full_name: Comon_.comul
code: /-- A comonoid object internal to a monoidal category.

When the monoidal category is preadditive, this is also sometimes called a "coalgebra object".
-/
structure Comon_ where
  /-- The underlying object of a comonoid object. -/
  X : C
  /-- The counit of a comonoid object. -/
  counit : X ⟶ 𝟙_ C
  /-- The comultiplication morphism of a comonoid object. -/
  comul : X ⟶ X ⊗ X
  counit_comul : comul ≫ (counit ▷ X) = (λ_ X).inv := by aesop_cat
  comul_counit : comul ≫ (X ◁ counit) = (ρ_ X).inv := by aesop_cat
  comul_assoc : comul ≫ (X ◁ comul) = comul ≫ (comul ▷ X) ≫ (α_ X X X).hom := by aesop_cat
goal: self.X ⟶ self.X ⊗ self.X

full_name: Comon_.comul_counit
code: /-- A comonoid object internal to a monoidal category.

When the monoidal category is preadditive, this is also sometimes called a "coalgebra object".
-/
structure Comon_ where
  /-- The underlying object of a comonoid object. -/
  X : C
  /-- The counit of a comonoid object. -/
  counit : X ⟶ 𝟙_ C
  /-- The comultiplication morphism of a comonoid object. -/
  comul : X ⟶ X ⊗ X
  counit_comul : comul ≫ (counit ▷ X) = (λ_ X).inv := by aesop_cat
  comul_counit : comul ≫ (X ◁ counit) = (ρ_ X).inv := by aesop_cat
  comul_assoc : comul ≫ (X ◁ comul) = comul ≫ (comul ▷ X) ≫ (α_ X X X).hom := by aesop_cat
goal: self.comul ≫ self.X ◁ self.counit = (ρ_ self.X).inv

full_name: Comon_.X
code: /-- A comonoid object internal to a monoidal category.

When the monoidal category is preadditive, this is also sometimes called a "coalgebra object".
-/
structure Comon_ where
  /-- The underlying object of a comonoid object. -/
  X : C
  /-- The counit of a comonoid object. -/
  counit : X ⟶ 𝟙_ C
  /-- The comultiplication morphism of a comonoid object. -/
  comul : X ⟶ X ⊗ X
  counit_comul : comul ≫ (counit ▷ X) = (λ_ X).inv := by aesop_cat
  comul_counit : comul ≫ (X ◁ counit) = (ρ_ X).inv := by aesop_cat
  comul_assoc : comul ≫ (X ◁ comul) = comul ≫ (comul ▷ X) ≫ (α_ X X X).hom := by aesop_cat
goal: C

full_name: Comon_.counit_comul
code: /-- A comonoid object internal to a monoidal category.

When the monoidal category is preadditive, this is also sometimes called a "coalgebra object".
-/
structure Comon_ where
  /-- The underlying object of a comonoid object. -/
  X : C
  /-- The counit of a comonoid object. -/
  counit : X ⟶ 𝟙_ C
  /-- The comultiplication morphism of a comonoid object. -/
  comul : X ⟶ X ⊗ X
  counit_comul : comul ≫ (counit ▷ X) = (λ_ X).inv := by aesop_cat
  comul_counit : comul ≫ (X ◁ counit) = (ρ_ X).inv := by aesop_cat
  comul_assoc : comul ≫ (X ◁ comul) = comul ≫ (comul ▷ X) ≫ (α_ X X X).hom := by aesop_cat
goal: self.comul ≫ self.counit ▷ self.X = (λ_ self.X).inv

full_name: Comon_
code: /-- A comonoid object internal to a monoidal category.

When the monoidal category is preadditive, this is also sometimes called a "coalgebra object".
-/
structure Comon_ where
  /-- The underlying object of a comonoid object. -/
  X : C
  /-- The counit of a comonoid object. -/
  counit : X ⟶ 𝟙_ C
  /-- The comultiplication morphism of a comonoid object. -/
  comul : X ⟶ X ⊗ X
  counit_comul : comul ≫ (counit ▷ X) = (λ_ X).inv := by aesop_cat
  comul_counit : comul ≫ (X ◁ counit) = (ρ_ X).inv := by aesop_cat
  comul_assoc : comul ≫ (X ◁ comul) = comul ≫ (comul ▷ X) ≫ (α_ X X X).hom := by aesop_cat
goal: Type (max u₁ v₁)

full_name: Comon_.trivial
code: /-- The trivial comonoid object. We later show this is terminal in `Comon_ C`.
-/
@[simps]
def trivial : Comon_ C 
goal: Comon_ C

full_name: Comon_.trivial_counit
code: /-- The trivial comonoid object. We later show this is terminal in `Comon_ C`.
-/
@[simps]
def trivial : Comon_ C 
goal: (Comon_.trivial C).counit = 𝟙 (𝟙_ C)

full_name: Comon_.trivial_comul
code: /-- The trivial comonoid object. We later show this is terminal in `Comon_ C`.
-/
@[simps]
def trivial : Comon_ C 
goal: (Comon_.trivial C).comul = (λ_ (𝟙_ C)).inv

full_name: Comon_.trivial_X
code: /-- The trivial comonoid object. We later show this is terminal in `Comon_ C`.
-/
@[simps]
def trivial : Comon_ C 
goal: (Comon_.trivial C).X = 𝟙_ C

full_name: Comon_.instInhabited
code: instance : Inhabited (Comon_ C) 
goal: Inhabited (Comon_ C)

full_name: Comon_.counit_comul_hom
code: @[reassoc (attr := simp)]
theorem counit_comul_hom {Z : C} (f : M.X ⟶ Z) : M.comul ≫ (M.counit ⊗ f) = f ≫ (λ_ Z).inv 
goal: M.comul ≫ (M.counit ⊗ f) = f ≫ (λ_ Z).inv

full_name: Comon_.comul_counit_hom
code: @[reassoc (attr := simp)]
theorem comul_counit_hom {Z : C} (f : M.X ⟶ Z) : M.comul ≫ (f ⊗ M.counit) = f ≫ (ρ_ Z).inv 
goal: M.comul ≫ (f ⊗ M.counit) = f ≫ (ρ_ Z).inv

full_name: Comon_.comul_assoc_flip
code: @[reassoc] theorem comul_assoc_flip :
    M.comul ≫ (M.comul ▷ M.X) = M.comul ≫ (M.X ◁ M.comul) ≫ (α_ M.X M.X M.X).inv 
goal: M.comul ≫ M.comul ▷ M.X = M.comul ≫ M.X ◁ M.comul ≫ (α_ M.X M.X M.X).inv

full_name: Comon_.Hom
code: /-- A morphism of comonoid objects. -/
@[ext]
structure Hom (M N : Comon_ C) where
  /-- The underlying morphism of a morphism of comonoid objects. -/
  hom : M.X ⟶ N.X
  hom_counit : hom ≫ N.counit = M.counit := by aesop_cat
  hom_comul : hom ≫ N.comul = M.comul ≫ (hom ⊗ hom) := by aesop_cat
goal: Type v₁

full_name: Comon_.Hom.hom
code: /-- A morphism of comonoid objects. -/
@[ext]
structure Hom (M N : Comon_ C) where
  /-- The underlying morphism of a morphism of comonoid objects. -/
  hom : M.X ⟶ N.X
  hom_counit : hom ≫ N.counit = M.counit := by aesop_cat
  hom_comul : hom ≫ N.comul = M.comul ≫ (hom ⊗ hom) := by aesop_cat
goal: M.X ⟶ N.X

full_name: Comon_.Hom.hom_counit
code: /-- A morphism of comonoid objects. -/
@[ext]
structure Hom (M N : Comon_ C) where
  /-- The underlying morphism of a morphism of comonoid objects. -/
  hom : M.X ⟶ N.X
  hom_counit : hom ≫ N.counit = M.counit := by aesop_cat
  hom_comul : hom ≫ N.comul = M.comul ≫ (hom ⊗ hom) := by aesop_cat
goal: self.hom ≫ N.counit = M.counit

full_name: Comon_.Hom.hom_comul
code: /-- A morphism of comonoid objects. -/
@[ext]
structure Hom (M N : Comon_ C) where
  /-- The underlying morphism of a morphism of comonoid objects. -/
  hom : M.X ⟶ N.X
  hom_counit : hom ≫ N.counit = M.counit := by aesop_cat
  hom_comul : hom ≫ N.comul = M.comul ≫ (hom ⊗ hom) := by aesop_cat
goal: self.hom ≫ N.comul = M.comul ≫ (self.hom ⊗ self.hom)

full_name: Comon_.id_hom
code: /-- The identity morphism on a comonoid object. -/
@[simps]
def id (M : Comon_ C) : Hom M M 
goal: M.id.hom = 𝟙 M.X

full_name: Comon_.id
code: /-- The identity morphism on a comonoid object. -/
@[simps]
def id (M : Comon_ C) : Hom M M 
goal: M.Hom M

full_name: Comon_.homInhabited
code: instance homInhabited (M : Comon_ C) : Inhabited (Hom M M) 
goal: Inhabited (M.Hom M)

full_name: Comon_.comp
code: /-- Composition of morphisms of monoid objects. -/
@[simps]
def comp {M N O : Comon_ C} (f : Hom M N) (g : Hom N O) : Hom M O 
goal: M.Hom O

full_name: Comon_.comp_hom
code: /-- Composition of morphisms of monoid objects. -/
@[simps]
def comp {M N O : Comon_ C} (f : Hom M N) (g : Hom N O) : Hom M O 
goal: (Comon_.comp f g).hom = f.hom ≫ g.hom

full_name: Comon_.instCategory
code: instance : Category (Comon_ C) 
goal: CategoryTheory.Category.{v₁, max u₁ v₁} (Comon_ C)

full_name: Comon_.ext
code: @[ext] lemma ext {X Y : Comon_ C} {f g : X ⟶ Y} (w : f.hom = g.hom) : f = g 
goal: f = g

full_name: Comon_.id_hom'
code: @[simp] theorem id_hom' (M : Comon_ C) : (𝟙 M : Hom M M).hom = 𝟙 M.X 
goal: (𝟙 M).hom = 𝟙 M.X

full_name: Comon_.comp_hom'
code: @[simp]
theorem comp_hom' {M N K : Comon_ C} (f : M ⟶ N) (g : N ⟶ K) : (f ≫ g).hom = f.hom ≫ g.hom 
goal: (f ≫ g).hom = f.hom ≫ g.hom

full_name: Comon_.forget
code: /-- The forgetful functor from comonoid objects to the ambient category. -/
@[simps]
def forget : Comon_ C ⥤ C 
goal: Comon_ C ⥤ C

full_name: Comon_.forget_obj
code: /-- The forgetful functor from comonoid objects to the ambient category. -/
@[simps]
def forget : Comon_ C ⥤ C 
goal: (Comon_.forget C).obj A = A.X

full_name: Comon_.forget_map
code: /-- The forgetful functor from comonoid objects to the ambient category. -/
@[simps]
def forget : Comon_ C ⥤ C 
goal: ∀ {X Y : Comon_ C} (f : X ⟶ Y), (Comon_.forget C).map f = f.hom

full_name: Comon_.forget_faithful
code: instance forget_faithful : (@forget C _ _).Faithful 
goal: (Comon_.forget C).Faithful

full_name: Comon_.instIsIsoHomOfMapForget
code: instance {A B : Comon_ C} (f : A ⟶ B) [e : IsIso ((forget C).map f)] : IsIso f.hom 
goal: CategoryTheory.IsIso f.hom

full_name: Comon_.instReflectsIsomorphismsForget
code: /-- The forgetful functor from comonoid objects to the ambient category reflects isomorphisms. -/
instance : (forget C).ReflectsIsomorphisms 
goal: (Comon_.forget C).ReflectsIsomorphisms

full_name: Comon_.mkIso
code: /-- Construct an isomorphism of comonoids by giving an isomorphism between the underlying objects
and checking compatibility with counit and comultiplication only in the forward direction.
-/
@[simps]
def mkIso {M N : Comon_ C} (f : M.X ≅ N.X) (f_counit : f.hom ≫ N.counit = M.counit := by aesop_cat)
    (f_comul : f.hom ≫ N.comul = M.comul ≫ (f.hom ⊗ f.hom) := by aesop_cat) : M ≅ N 
goal: M ≅ N

full_name: Comon_.mkIso_inv_hom
code: /-- Construct an isomorphism of comonoids by giving an isomorphism between the underlying objects
and checking compatibility with counit and comultiplication only in the forward direction.
-/
@[simps]
def mkIso {M N : Comon_ C} (f : M.X ≅ N.X) (f_counit : f.hom ≫ N.counit = M.counit := by aesop_cat)
    (f_comul : f.hom ≫ N.comul = M.comul ≫ (f.hom ⊗ f.hom) := by aesop_cat) : M ≅ N 
goal: (Comon_.mkIso f f_counit f_comul).inv.hom = f.inv

full_name: Comon_.mkIso_hom_hom
code: /-- Construct an isomorphism of comonoids by giving an isomorphism between the underlying objects
and checking compatibility with counit and comultiplication only in the forward direction.
-/
@[simps]
def mkIso {M N : Comon_ C} (f : M.X ≅ N.X) (f_counit : f.hom ≫ N.counit = M.counit := by aesop_cat)
    (f_comul : f.hom ≫ N.comul = M.comul ≫ (f.hom ⊗ f.hom) := by aesop_cat) : M ≅ N 
goal: (Comon_.mkIso f f_counit f_comul).hom.hom = f.hom

full_name: Comon_.uniqueHomToTrivial
code: instance uniqueHomToTrivial (A : Comon_ C) : Unique (A ⟶ trivial C) 
goal: Unique (A ⟶ Comon_.trivial C)

full_name: Comon_.instHasTerminal
code: instance : HasTerminal (Comon_ C) 
goal: CategoryTheory.Limits.HasTerminal (Comon_ C)

full_name: Comon_.Comon_ToMon_OpOp_obj'
code: /--
Turn a comonoid object into a monoid object in the opposite category.
-/
@[simps] def Comon_ToMon_OpOp_obj' (A : Comon_ C) : Mon_ (Cᵒᵖ) 
goal: Mon_ Cᵒᵖ

full_name: Comon_.Comon_ToMon_OpOp_obj'_one
code: /--
Turn a comonoid object into a monoid object in the opposite category.
-/
@[simps] def Comon_ToMon_OpOp_obj' (A : Comon_ C) : Mon_ (Cᵒᵖ) 
goal: (Comon_.Comon_ToMon_OpOp_obj' C A).one = A.counit.op

full_name: Comon_.Comon_ToMon_OpOp_obj'_mul
code: /--
Turn a comonoid object into a monoid object in the opposite category.
-/
@[simps] def Comon_ToMon_OpOp_obj' (A : Comon_ C) : Mon_ (Cᵒᵖ) 
goal: (Comon_.Comon_ToMon_OpOp_obj' C A).mul = A.comul.op

full_name: Comon_.Comon_ToMon_OpOp_obj'_X
code: /--
Turn a comonoid object into a monoid object in the opposite category.
-/
@[simps] def Comon_ToMon_OpOp_obj' (A : Comon_ C) : Mon_ (Cᵒᵖ) 
goal: (Comon_.Comon_ToMon_OpOp_obj' C A).X = Opposite.op A.X

full_name: Comon_.Comon_ToMon_OpOp_map
code: /--
The contravariant functor turning comonoid objects into monoid objects in the opposite category.
-/
@[simps] def Comon_ToMon_OpOp : Comon_ C ⥤ (Mon_ (Cᵒᵖ))ᵒᵖ 
goal: ∀ {X Y : Comon_ C} (f : X ⟶ Y),
  (Comon_.Comon_ToMon_OpOp C).map f = Opposite.op { hom := f.hom.op, one_hom := ⋯, mul_hom := ⋯ }

full_name: Comon_.Comon_ToMon_OpOp_obj
code: /--
The contravariant functor turning comonoid objects into monoid objects in the opposite category.
-/
@[simps] def Comon_ToMon_OpOp : Comon_ C ⥤ (Mon_ (Cᵒᵖ))ᵒᵖ 
goal: (Comon_.Comon_ToMon_OpOp C).obj A = Opposite.op (Comon_.Comon_ToMon_OpOp_obj' C A)

full_name: Comon_.Comon_ToMon_OpOp
code: /--
The contravariant functor turning comonoid objects into monoid objects in the opposite category.
-/
@[simps] def Comon_ToMon_OpOp : Comon_ C ⥤ (Mon_ (Cᵒᵖ))ᵒᵖ 
goal: Comon_ C ⥤ (Mon_ Cᵒᵖ)ᵒᵖ

full_name: Comon_.Mon_OpOpToComon_obj'_counit
code: /--
Turn a monoid object in the opposite category into a comonoid object.
-/
@[simps] def Mon_OpOpToComon_obj' (A : (Mon_ (Cᵒᵖ))) : Comon_ C 
goal: (Comon_.Mon_OpOpToComon_obj' C A).counit = A.one.unop

full_name: Comon_.Mon_OpOpToComon_obj'_comul
code: /--
Turn a monoid object in the opposite category into a comonoid object.
-/
@[simps] def Mon_OpOpToComon_obj' (A : (Mon_ (Cᵒᵖ))) : Comon_ C 
goal: (Comon_.Mon_OpOpToComon_obj' C A).comul = A.mul.unop

full_name: Comon_.Mon_OpOpToComon_obj'_X
code: /--
Turn a monoid object in the opposite category into a comonoid object.
-/
@[simps] def Mon_OpOpToComon_obj' (A : (Mon_ (Cᵒᵖ))) : Comon_ C 
goal: (Comon_.Mon_OpOpToComon_obj' C A).X = Opposite.unop A.X

full_name: Comon_.Mon_OpOpToComon_obj'
code: /--
Turn a monoid object in the opposite category into a comonoid object.
-/
@[simps] def Mon_OpOpToComon_obj' (A : (Mon_ (Cᵒᵖ))) : Comon_ C 
goal: Comon_ C

full_name: Comon_.Mon_OpOpToComon__map_hom
code: /--
The contravariant functor turning monoid objects in the opposite category into comonoid objects.
-/
@[simps]
def Mon_OpOpToComon_ : (Mon_ (Cᵒᵖ))ᵒᵖ ⥤ Comon_ C 
goal: ∀ {X Y : (Mon_ Cᵒᵖ)ᵒᵖ} (f : X ⟶ Y), ((Comon_.Mon_OpOpToComon_ C).map f).hom = f.unop.hom.unop

full_name: Comon_.Mon_OpOpToComon_
code: /--
The contravariant functor turning monoid objects in the opposite category into comonoid objects.
-/
@[simps]
def Mon_OpOpToComon_ : (Mon_ (Cᵒᵖ))ᵒᵖ ⥤ Comon_ C 
goal: (Mon_ Cᵒᵖ)ᵒᵖ ⥤ Comon_ C

full_name: Comon_.Mon_OpOpToComon__obj
code: /--
The contravariant functor turning monoid objects in the opposite category into comonoid objects.
-/
@[simps]
def Mon_OpOpToComon_ : (Mon_ (Cᵒᵖ))ᵒᵖ ⥤ Comon_ C 
goal: (Comon_.Mon_OpOpToComon_ C).obj A = Comon_.Mon_OpOpToComon_obj' C (Opposite.unop A)

full_name: Comon_.Comon_EquivMon_OpOp_unitIso
code: /--
Comonoid objects are contravariantly equivalent to monoid objects in the opposite category.
-/
@[simps]
def Comon_EquivMon_OpOp : Comon_ C ≌ (Mon_ (Cᵒᵖ))ᵒᵖ 
goal: (Comon_.Comon_EquivMon_OpOp C).unitIso =
  CategoryTheory.NatIso.ofComponents (fun x => CategoryTheory.Iso.refl ((𝟭 (Comon_ C)).obj x)) ⋯

full_name: Comon_.Comon_EquivMon_OpOp_inverse
code: /--
Comonoid objects are contravariantly equivalent to monoid objects in the opposite category.
-/
@[simps]
def Comon_EquivMon_OpOp : Comon_ C ≌ (Mon_ (Cᵒᵖ))ᵒᵖ 
goal: (Comon_.Comon_EquivMon_OpOp C).inverse = Comon_.Mon_OpOpToComon_ C

full_name: Comon_.Comon_EquivMon_OpOp_functor
code: /--
Comonoid objects are contravariantly equivalent to monoid objects in the opposite category.
-/
@[simps]
def Comon_EquivMon_OpOp : Comon_ C ≌ (Mon_ (Cᵒᵖ))ᵒᵖ 
goal: (Comon_.Comon_EquivMon_OpOp C).functor = Comon_.Comon_ToMon_OpOp C

full_name: Comon_.Comon_EquivMon_OpOp
code: /--
Comonoid objects are contravariantly equivalent to monoid objects in the opposite category.
-/
@[simps]
def Comon_EquivMon_OpOp : Comon_ C ≌ (Mon_ (Cᵒᵖ))ᵒᵖ 
goal: Comon_ C ≌ (Mon_ Cᵒᵖ)ᵒᵖ

full_name: Comon_.Comon_EquivMon_OpOp_counitIso
code: /--
Comonoid objects are contravariantly equivalent to monoid objects in the opposite category.
-/
@[simps]
def Comon_EquivMon_OpOp : Comon_ C ≌ (Mon_ (Cᵒᵖ))ᵒᵖ 
goal: (Comon_.Comon_EquivMon_OpOp C).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun x => CategoryTheory.Iso.refl ((Comon_.Mon_OpOpToComon_ C ⋙ Comon_.Comon_ToMon_OpOp C).obj x)) ⋯

full_name: Comon_.instMonoidalCategoryOfBraidedCategory
code: /--
Comonoid objects in a braided category form a monoidal category.

This definition is via transporting back and forth to monoids in the opposite category,
-/
instance [BraidedCategory C] : MonoidalCategory (Comon_ C) 
goal: CategoryTheory.MonoidalCategory (Comon_ C)

full_name: Comon_.tensorObj_X
code: theorem tensorObj_X (A B : Comon_ C) : (A ⊗ B).X = A.X ⊗ B.X 
goal: (A ⊗ B).X = A.X ⊗ B.X

full_name: Comon_.tensorObj_counit
code: theorem tensorObj_counit (A B : Comon_ C) : (A ⊗ B).counit = (A.counit ⊗ B.counit) ≫ (λ_ _).hom 
goal: (A ⊗ B).counit = (A.counit ⊗ B.counit) ≫ (λ_ (𝟙_ C)).hom

full_name: Comon_.tensorObj_comul'
code: /--
Preliminary statement of the comultiplication for a tensor product of comonoids.
This version is the definitional equality provided by transport, and not quite as good as
the version provided in `tensorObj_comul` below.
-/
theorem tensorObj_comul' (A B : Comon_ C) :
    (A ⊗ B).comul =
      (A.comul ⊗ B.comul) ≫ (tensor_μ Cᵒᵖ (op A.X, op B.X) (op A.X, op B.X)).unop 
goal: (A ⊗ B).comul =
  (A.comul ⊗ B.comul) ≫
    (CategoryTheory.tensor_μ Cᵒᵖ (Opposite.op A.X, Opposite.op B.X) (Opposite.op A.X, Opposite.op B.X)).unop

full_name: Comon_.tensorObj_comul
code: /--
The comultiplication on the tensor product of two comonoids is
the tensor product of the comultiplications followed by the tensor strength
(to shuffle the factors back into order).
-/
theorem tensorObj_comul (A B : Comon_ C) :
    (A ⊗ B).comul = (A.comul ⊗ B.comul) ≫ tensor_μ C (A.X, A.X) (B.X, B.X) 
goal: (A ⊗ B).comul = (A.comul ⊗ B.comul) ≫ CategoryTheory.tensor_μ C (A.X, A.X) (B.X, B.X)

full_name: Comon_.forgetMonoidal
code: /-- The forgetful functor from `Comon_ C` to `C` is monoidal when `C` is braided monoidal. -/
def forgetMonoidal : MonoidalFunctor (Comon_ C) C 
goal: CategoryTheory.MonoidalFunctor (Comon_ C) C

full_name: Comon_.forgetMonoidal_toFunctor
code: @[simp] theorem forgetMonoidal_toFunctor : (forgetMonoidal C).toFunctor = forget C 
goal: (Comon_.forgetMonoidal C).toFunctor = Comon_.forget C

full_name: Comon_.forgetMonoidal_ε
code: @[simp] theorem forgetMonoidal_ε : (forgetMonoidal C).ε = 𝟙 (𝟙_ C) 
goal: (Comon_.forgetMonoidal C).ε = 𝟙 (𝟙_ C)

full_name: Comon_.forgetMonoidal_μ
code: @[simp] theorem forgetMonoidal_μ (X Y : Comon_ C) : (forgetMonoidal C).μ X Y = 𝟙 (X.X ⊗ Y.X) 
goal: (Comon_.forgetMonoidal C).μ X Y = 𝟙 (X.X ⊗ Y.X)

full_name: CategoryTheory.OplaxMonoidalFunctor.mapComon
code: /-- A oplax monoidal functor takes comonoid objects to comonoid objects.

That is, a oplax monoidal functor `F : C ⥤ D` induces a functor `Comon_ C ⥤ Comon_ D`.
-/
@[simps]
def mapComon (F : OplaxMonoidalFunctor C D) : Comon_ C ⥤ Comon_ D 
goal: Comon_ C ⥤ Comon_ D

full_name: CategoryTheory.OplaxMonoidalFunctor.mapComon_obj_comul
code: /-- A oplax monoidal functor takes comonoid objects to comonoid objects.

That is, a oplax monoidal functor `F : C ⥤ D` induces a functor `Comon_ C ⥤ Comon_ D`.
-/
@[simps]
def mapComon (F : OplaxMonoidalFunctor C D) : Comon_ C ⥤ Comon_ D 
goal: (F.mapComon.obj A).comul = F.map A.comul ≫ F.δ A.X A.X

full_name: CategoryTheory.OplaxMonoidalFunctor.mapComon_map_hom
code: /-- A oplax monoidal functor takes comonoid objects to comonoid objects.

That is, a oplax monoidal functor `F : C ⥤ D` induces a functor `Comon_ C ⥤ Comon_ D`.
-/
@[simps]
def mapComon (F : OplaxMonoidalFunctor C D) : Comon_ C ⥤ Comon_ D 
goal: ∀ {X Y : Comon_ C} (f : X ⟶ Y), (F.mapComon.map f).hom = F.map f.hom

full_name: CategoryTheory.OplaxMonoidalFunctor.mapComon_obj_X
code: /-- A oplax monoidal functor takes comonoid objects to comonoid objects.

That is, a oplax monoidal functor `F : C ⥤ D` induces a functor `Comon_ C ⥤ Comon_ D`.
-/
@[simps]
def mapComon (F : OplaxMonoidalFunctor C D) : Comon_ C ⥤ Comon_ D 
goal: (F.mapComon.obj A).X = F.obj A.X

full_name: CategoryTheory.OplaxMonoidalFunctor.mapComon_obj_counit
code: /-- A oplax monoidal functor takes comonoid objects to comonoid objects.

That is, a oplax monoidal functor `F : C ⥤ D` induces a functor `Comon_ C ⥤ Comon_ D`.
-/
@[simps]
def mapComon (F : OplaxMonoidalFunctor C D) : Comon_ C ⥤ Comon_ D 
goal: (F.mapComon.obj A).counit = F.map A.counit ≫ F.η