File: Mathlib/Algebra/Category/CoalgebraCat/ComonEquivalence.lean

full_name: CoalgebraCat.toComonObj_X
code: /-- An `R`-coalgebra is a comonoid object in the category of `R`-modules. -/
@[simps] def toComonObj (X : CoalgebraCat R) : Comon_ (ModuleCat R) 
goal: X.toComonObj.X = ModuleCat.of R ↑X.toModuleCat

full_name: CoalgebraCat.toComonObj_counit
code: /-- An `R`-coalgebra is a comonoid object in the category of `R`-modules. -/
@[simps] def toComonObj (X : CoalgebraCat R) : Comon_ (ModuleCat R) 
goal: X.toComonObj.counit = ModuleCat.ofHom Coalgebra.counit

full_name: CoalgebraCat.toComonObj_comul
code: /-- An `R`-coalgebra is a comonoid object in the category of `R`-modules. -/
@[simps] def toComonObj (X : CoalgebraCat R) : Comon_ (ModuleCat R) 
goal: X.toComonObj.comul = ModuleCat.ofHom Coalgebra.comul

full_name: CoalgebraCat.toComonObj
code: /-- An `R`-coalgebra is a comonoid object in the category of `R`-modules. -/
@[simps] def toComonObj (X : CoalgebraCat R) : Comon_ (ModuleCat R) 
goal: Comon_ (ModuleCat R)

full_name: CoalgebraCat.toComon_map_hom
code: /-- The natural functor from `R`-coalgebras to comonoid objects in the category of `R`-modules. -/
@[simps]
def toComon : CoalgebraCat R ⥤ Comon_ (ModuleCat R) 
goal: ∀ {X Y : CoalgebraCat R} (f : X ⟶ Y), ((CoalgebraCat.toComon R).map f).hom = ModuleCat.ofHom ↑f.toCoalgHom

full_name: CoalgebraCat.toComon_obj
code: /-- The natural functor from `R`-coalgebras to comonoid objects in the category of `R`-modules. -/
@[simps]
def toComon : CoalgebraCat R ⥤ Comon_ (ModuleCat R) 
goal: (CoalgebraCat.toComon R).obj X = X.toComonObj

full_name: CoalgebraCat.toComon
code: /-- The natural functor from `R`-coalgebras to comonoid objects in the category of `R`-modules. -/
@[simps]
def toComon : CoalgebraCat R ⥤ Comon_ (ModuleCat R) 
goal: CategoryTheory.Functor (CoalgebraCat R) (Comon_ (ModuleCat R))

full_name: CoalgebraCat.ofComonObjCoalgebraStruct_comul
code: /-- A comonoid object in the category of `R`-modules has a natural comultiplication
and counit. -/
@[simps]
instance ofComonObjCoalgebraStruct (X : Comon_ (ModuleCat R)) :
    CoalgebraStruct R X.X 
goal: Coalgebra.comul = X.comul

full_name: CoalgebraCat.ofComonObjCoalgebraStruct_counit
code: /-- A comonoid object in the category of `R`-modules has a natural comultiplication
and counit. -/
@[simps]
instance ofComonObjCoalgebraStruct (X : Comon_ (ModuleCat R)) :
    CoalgebraStruct R X.X 
goal: Coalgebra.counit = X.counit

full_name: CoalgebraCat.ofComonObjCoalgebraStruct
code: /-- A comonoid object in the category of `R`-modules has a natural comultiplication
and counit. -/
@[simps]
instance ofComonObjCoalgebraStruct (X : Comon_ (ModuleCat R)) :
    CoalgebraStruct R X.X 
goal: CoalgebraStruct R ↑X.X

full_name: CoalgebraCat.ofComonObj
code: /-- A comonoid object in the category of `R`-modules has a natural `R`-coalgebra
structure. -/
def ofComonObj (X : Comon_ (ModuleCat R)) : CoalgebraCat R 
goal: CoalgebraCat R

full_name: CoalgebraCat.ofComon
code: /-- The natural functor from comonoid objects in the category of `R`-modules to `R`-coalgebras. -/
def ofComon : Comon_ (ModuleCat R) ⥤ CoalgebraCat R 
goal: CategoryTheory.Functor (Comon_ (ModuleCat R)) (CoalgebraCat R)

full_name: CoalgebraCat.comonEquivalence_functor
code: /-- The natural category equivalence between `R`-coalgebras and comonoid objects in the
category of `R`-modules. -/
@[simps]
noncomputable def comonEquivalence : CoalgebraCat R ≌ Comon_ (ModuleCat R) 
goal: (CoalgebraCat.comonEquivalence R).functor = CoalgebraCat.toComon R

full_name: CoalgebraCat.comonEquivalence_inverse
code: /-- The natural category equivalence between `R`-coalgebras and comonoid objects in the
category of `R`-modules. -/
@[simps]
noncomputable def comonEquivalence : CoalgebraCat R ≌ Comon_ (ModuleCat R) 
goal: (CoalgebraCat.comonEquivalence R).inverse = CoalgebraCat.ofComon R

full_name: CoalgebraCat.comonEquivalence_unitIso
code: /-- The natural category equivalence between `R`-coalgebras and comonoid objects in the
category of `R`-modules. -/
@[simps]
noncomputable def comonEquivalence : CoalgebraCat R ≌ Comon_ (ModuleCat R) 
goal: (CoalgebraCat.comonEquivalence R).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun x => CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CoalgebraCat R)).obj x)) ⋯

full_name: CoalgebraCat.comonEquivalence_counitIso
code: /-- The natural category equivalence between `R`-coalgebras and comonoid objects in the
category of `R`-modules. -/
@[simps]
noncomputable def comonEquivalence : CoalgebraCat R ≌ Comon_ (ModuleCat R) 
goal: (CoalgebraCat.comonEquivalence R).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun x => CategoryTheory.Iso.refl (((CoalgebraCat.ofComon R).comp (CoalgebraCat.toComon R)).obj x)) ⋯

full_name: CoalgebraCat.comonEquivalence
code: /-- The natural category equivalence between `R`-coalgebras and comonoid objects in the
category of `R`-modules. -/
@[simps]
noncomputable def comonEquivalence : CoalgebraCat R ≌ Comon_ (ModuleCat R) 
goal: CoalgebraCat R ≌ Comon_ (ModuleCat R)

full_name: CoalgebraCat.instMonoidalCategoryAux
code: /-- The monoidal category structure on the category of `R`-coalgebras induced by the
equivalence with `Comon(R-Mod)`. This is just an auxiliary definition; the `MonoidalCategory`
instance we make in `Mathlib.Algebra.Category.CoalgebraCat.Monoidal` in #11976 will have better
definitional equalities. -/
noncomputable def instMonoidalCategoryAux : MonoidalCategory (CoalgebraCat R) 
goal: CategoryTheory.MonoidalCategory (CoalgebraCat R)

full_name: CoalgebraCat.MonoidalCategoryAux.tensorObj_comul
code: theorem tensorObj_comul (K L : CoalgebraCat R) :
    Coalgebra.comul (R := R) (A := (K ⊗ L : CoalgebraCat R))
      = (TensorProduct.tensorTensorTensorComm R K K L L).toLinearMap
      ∘ₗ TensorProduct.map Coalgebra.comul Coalgebra.comul 
goal: Coalgebra.comul =
  ↑(TensorProduct.tensorTensorTensorComm R ↑K.toModuleCat ↑K.toModuleCat ↑L.toModuleCat ↑L.toModuleCat) ∘ₗ
    TensorProduct.map Coalgebra.comul Coalgebra.comul

full_name: CoalgebraCat.MonoidalCategoryAux.tensorHom_toLinearMap
code: theorem tensorHom_toLinearMap (f : M →ₗc[R] N) (g : P →ₗc[R] Q) :
    (CoalgebraCat.ofHom f ⊗ CoalgebraCat.ofHom g).1.toLinearMap
      = TensorProduct.map f.toLinearMap g.toLinearMap 
goal: (CategoryTheory.MonoidalCategory.tensorHom (CoalgebraCat.ofHom f) (CoalgebraCat.ofHom g)).toCoalgHom.toLinearMap =
  TensorProduct.map f.toLinearMap g.toLinearMap

full_name: CoalgebraCat.MonoidalCategoryAux.associator_hom_toLinearMap
code: theorem associator_hom_toLinearMap :
    (α_ (CoalgebraCat.of R M) (CoalgebraCat.of R N) (CoalgebraCat.of R P)).hom.1.toLinearMap
      = (TensorProduct.assoc R M N P).toLinearMap 
goal: (CategoryTheory.MonoidalCategory.associator (CoalgebraCat.of R M) (CoalgebraCat.of R N)
          (CoalgebraCat.of R P)).hom.toCoalgHom.toLinearMap =
  ↑(TensorProduct.assoc R M N P)

full_name: CoalgebraCat.MonoidalCategoryAux.leftUnitor_hom_toLinearMap
code: theorem leftUnitor_hom_toLinearMap :
    (λ_ (CoalgebraCat.of R M)).hom.1.toLinearMap = (TensorProduct.lid R M).toLinearMap 
goal: (CategoryTheory.MonoidalCategory.leftUnitor (CoalgebraCat.of R M)).hom.toCoalgHom.toLinearMap = ↑(TensorProduct.lid R M)

full_name: CoalgebraCat.MonoidalCategoryAux.rightUnitor_hom_toLinearMap
code: theorem rightUnitor_hom_toLinearMap :
    (ρ_ (CoalgebraCat.of R M)).hom.1.toLinearMap = (TensorProduct.rid R M).toLinearMap 
goal: (CategoryTheory.MonoidalCategory.rightUnitor (CoalgebraCat.of R M)).hom.toCoalgHom.toLinearMap =
  ↑(TensorProduct.rid R M)

full_name: CoalgebraCat.MonoidalCategoryAux.comul_tensorObj
code: theorem comul_tensorObj :
    Coalgebra.comul (R := R) (A := (CoalgebraCat.of R M ⊗ CoalgebraCat.of R N : CoalgebraCat R))
      = Coalgebra.comul (A := M ⊗[R] N) 
goal: Coalgebra.comul = Coalgebra.comul

full_name: CoalgebraCat.MonoidalCategoryAux.comul_tensorObj_tensorObj_right
code: theorem comul_tensorObj_tensorObj_right :
    Coalgebra.comul (R := R) (A := (CoalgebraCat.of R M ⊗
      (CoalgebraCat.of R N ⊗ CoalgebraCat.of R P) : CoalgebraCat R))
      = Coalgebra.comul (A := M ⊗[R] N ⊗[R] P) 
goal: Coalgebra.comul = Coalgebra.comul

full_name: CoalgebraCat.MonoidalCategoryAux.comul_tensorObj_tensorObj_left
code: theorem comul_tensorObj_tensorObj_left :
    Coalgebra.comul (R := R)
      (A := ((CoalgebraCat.of R M ⊗ CoalgebraCat.of R N) ⊗ CoalgebraCat.of R P : CoalgebraCat R))
      = Coalgebra.comul (A := (M ⊗[R] N) ⊗[R] P) 
goal: Coalgebra.comul = Coalgebra.comul

full_name: CoalgebraCat.MonoidalCategoryAux.counit_tensorObj
code: theorem counit_tensorObj :
    Coalgebra.counit (R := R) (A := (CoalgebraCat.of R M ⊗ CoalgebraCat.of R N : CoalgebraCat R))
      = Coalgebra.counit (A := M ⊗[R] N) 
goal: Coalgebra.counit = Coalgebra.counit

full_name: CoalgebraCat.MonoidalCategoryAux.counit_tensorObj_tensorObj_right
code: theorem counit_tensorObj_tensorObj_right :
    Coalgebra.counit (R := R)
      (A := (CoalgebraCat.of R M ⊗ (CoalgebraCat.of R N ⊗ CoalgebraCat.of R P) : CoalgebraCat R))
      = Coalgebra.counit (A := M ⊗[R] (N ⊗[R] P)) 
goal: Coalgebra.counit = Coalgebra.counit

full_name: CoalgebraCat.MonoidalCategoryAux.counit_tensorObj_tensorObj_left
code: theorem counit_tensorObj_tensorObj_left :
    Coalgebra.counit (R := R)
      (A := ((CoalgebraCat.of R M ⊗ CoalgebraCat.of R N) ⊗ CoalgebraCat.of R P : CoalgebraCat R))
      = Coalgebra.counit (A := (M ⊗[R] N) ⊗[R] P) 
goal: Coalgebra.counit = Coalgebra.counit