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

full_name: CoalgebraCat.instCoalgebra
code: /-- The category of `R`-coalgebras. -/
structure CoalgebraCat extends ModuleCat.{v} R where
  instCoalgebra : Coalgebra R carrier
goal: Coalgebra R ↑self.toModuleCat

full_name: CoalgebraCat
code: /-- The category of `R`-coalgebras. -/
structure CoalgebraCat extends ModuleCat.{v} R where
  instCoalgebra : Coalgebra R carrier
goal: Type (max u (v + 1))

full_name: CoalgebraCat.instCoeSortType
code: instance : CoeSort (CoalgebraCat.{v} R) (Type v) 
goal: CoeSort (CoalgebraCat R) (Type v)

full_name: CoalgebraCat.moduleCat_of_toModuleCat
code: @[simp] theorem moduleCat_of_toModuleCat (X : CoalgebraCat.{v} R) :
    ModuleCat.of R X.toModuleCat = X.toModuleCat 
goal: ModuleCat.of R ↑X.toModuleCat = X.toModuleCat

full_name: CoalgebraCat.of_isModule
code: /-- The object in the category of `R`-coalgebras associated to an `R`-coalgebra. -/
@[simps]
def of (X : Type v) [AddCommGroup X] [Module R X] [Coalgebra R X] :
    CoalgebraCat R 
goal: (CoalgebraCat.of R X).isModule = inst✝

full_name: CoalgebraCat.of_isAddCommGroup
code: /-- The object in the category of `R`-coalgebras associated to an `R`-coalgebra. -/
@[simps]
def of (X : Type v) [AddCommGroup X] [Module R X] [Coalgebra R X] :
    CoalgebraCat R 
goal: (CoalgebraCat.of R X).isAddCommGroup = inst✝

full_name: CoalgebraCat.of_instCoalgebra
code: /-- The object in the category of `R`-coalgebras associated to an `R`-coalgebra. -/
@[simps]
def of (X : Type v) [AddCommGroup X] [Module R X] [Coalgebra R X] :
    CoalgebraCat R 
goal: (CoalgebraCat.of R X).instCoalgebra = inferInstance

full_name: CoalgebraCat.of_carrier
code: /-- The object in the category of `R`-coalgebras associated to an `R`-coalgebra. -/
@[simps]
def of (X : Type v) [AddCommGroup X] [Module R X] [Coalgebra R X] :
    CoalgebraCat R 
goal: ↑(CoalgebraCat.of R X).toModuleCat = X

full_name: CoalgebraCat.of
code: /-- The object in the category of `R`-coalgebras associated to an `R`-coalgebra. -/
@[simps]
def of (X : Type v) [AddCommGroup X] [Module R X] [Coalgebra R X] :
    CoalgebraCat R 
goal: CoalgebraCat R

full_name: CoalgebraCat.of_comul
code: @[simp]
lemma of_comul {X : Type v} [AddCommGroup X] [Module R X] [Coalgebra R X] :
    Coalgebra.comul (A := of R X) = Coalgebra.comul (R := R) (A := X) 
goal: Coalgebra.comul = Coalgebra.comul

full_name: CoalgebraCat.of_counit
code: @[simp]
lemma of_counit {X : Type v} [AddCommGroup X] [Module R X] [Coalgebra R X] :
    Coalgebra.counit (A := of R X) = Coalgebra.counit (R := R) (A := X) 
goal: Coalgebra.counit = Coalgebra.counit

full_name: CoalgebraCat.Hom.toCoalgHom
code: /-- A type alias for `CoalgHom` to avoid confusion between the categorical and
algebraic spellings of composition. -/
@[ext]
structure Hom (V W : CoalgebraCat.{v} R) :=
  /-- The underlying `CoalgHom` -/
  toCoalgHom : V →ₗc[R] W
goal: ↑V.toModuleCat →ₗc[R] ↑W.toModuleCat

full_name: CoalgebraCat.Hom
code: /-- A type alias for `CoalgHom` to avoid confusion between the categorical and
algebraic spellings of composition. -/
@[ext]
structure Hom (V W : CoalgebraCat.{v} R) :=
  /-- The underlying `CoalgHom` -/
  toCoalgHom : V →ₗc[R] W
goal: Type v

full_name: CoalgebraCat.Hom.toCoalgHom_injective
code: lemma Hom.toCoalgHom_injective (V W : CoalgebraCat.{v} R) :
    Function.Injective (Hom.toCoalgHom : Hom V W → _) 
goal: Function.Injective CoalgebraCat.Hom.toCoalgHom

full_name: CoalgebraCat.category
code: instance category : Category (CoalgebraCat.{v} R) 
goal: CategoryTheory.Category.{v, max (v + 1) u} (CoalgebraCat R)

full_name: CoalgebraCat.hom_ext
code: @[ext]
lemma hom_ext {M N : CoalgebraCat.{v} R} (f g : M ⟶ N) (h : f.toCoalgHom = g.toCoalgHom) :
    f = g 
goal: f = g

full_name: CoalgebraCat.ofHom
code: /-- Typecheck a `CoalgHom` as a morphism in `CoalgebraCat R`. -/
abbrev ofHom {X Y : Type v} [AddCommGroup X] [Module R X] [AddCommGroup Y] [Module R Y]
    [Coalgebra R X] [Coalgebra R Y] (f : X →ₗc[R] Y) :
    of R X ⟶ of R Y 
goal: CoalgebraCat.of R X ⟶ CoalgebraCat.of R Y

full_name: CoalgebraCat.toCoalgHom_comp
code: @[simp] theorem toCoalgHom_comp {M N U : CoalgebraCat.{v} R} (f : M ⟶ N) (g : N ⟶ U) :
    (f ≫ g).toCoalgHom = g.toCoalgHom.comp f.toCoalgHom 
goal: (f ≫ g).toCoalgHom = g.toCoalgHom.comp f.toCoalgHom

full_name: CoalgebraCat.toCoalgHom_id
code: @[simp] theorem toCoalgHom_id {M : CoalgebraCat.{v} R} :
    Hom.toCoalgHom (𝟙 M) = CoalgHom.id _ _ 
goal: (𝟙 M).toCoalgHom = CoalgHom.id R ↑M.toModuleCat

full_name: CoalgebraCat.concreteCategory
code: instance concreteCategory : ConcreteCategory.{v} (CoalgebraCat.{v} R) 
goal: CategoryTheory.ConcreteCategory (CoalgebraCat R)

full_name: CoalgebraCat.hasForgetToModule
code: instance hasForgetToModule : HasForget₂ (CoalgebraCat R) (ModuleCat R) 
goal: CategoryTheory.HasForget₂ (CoalgebraCat R) (ModuleCat R)

full_name: CoalgebraCat.forget₂_obj
code: @[simp]
theorem forget₂_obj (X : CoalgebraCat R) :
    (forget₂ (CoalgebraCat R) (ModuleCat R)).obj X = ModuleCat.of R X 
goal: (CategoryTheory.forget₂ (CoalgebraCat R) (ModuleCat R)).obj X = ModuleCat.of R ↑X.toModuleCat

full_name: CoalgebraCat.forget₂_map
code: @[simp]
theorem forget₂_map (X Y : CoalgebraCat R) (f : X ⟶ Y) :
    (forget₂ (CoalgebraCat R) (ModuleCat R)).map f = (f.toCoalgHom : X →ₗ[R] Y) 
goal: (CategoryTheory.forget₂ (CoalgebraCat R) (ModuleCat R)).map f = ↑f.toCoalgHom

full_name: CoalgEquiv.toCoalgebraCatIso_inv_toCoalgHom
code: /-- Build an isomorphism in the category `CoalgebraCat R` from a
`CoalgEquiv`. -/
@[simps]
def toCoalgebraCatIso (e : X ≃ₗc[R] Y) : CoalgebraCat.of R X ≅ CoalgebraCat.of R Y 
goal: e.toCoalgebraCatIso.inv.toCoalgHom = ↑e.symm

full_name: CoalgEquiv.toCoalgebraCatIso
code: /-- Build an isomorphism in the category `CoalgebraCat R` from a
`CoalgEquiv`. -/
@[simps]
def toCoalgebraCatIso (e : X ≃ₗc[R] Y) : CoalgebraCat.of R X ≅ CoalgebraCat.of R Y 
goal: CoalgebraCat.of R X ≅ CoalgebraCat.of R Y

full_name: CoalgEquiv.toCoalgebraCatIso_hom_toCoalgHom
code: /-- Build an isomorphism in the category `CoalgebraCat R` from a
`CoalgEquiv`. -/
@[simps]
def toCoalgebraCatIso (e : X ≃ₗc[R] Y) : CoalgebraCat.of R X ≅ CoalgebraCat.of R Y 
goal: e.toCoalgebraCatIso.hom.toCoalgHom = ↑e

full_name: CoalgEquiv.toCoalgebraCatIso_refl
code: @[simp] theorem toCoalgebraCatIso_refl :
    toCoalgebraCatIso (CoalgEquiv.refl R X) = .refl _ 
goal: (CoalgEquiv.refl R X).toCoalgebraCatIso = CategoryTheory.Iso.refl (CoalgebraCat.of R X)

full_name: CoalgEquiv.toCoalgebraCatIso_symm
code: @[simp] theorem toCoalgebraCatIso_symm (e : X ≃ₗc[R] Y) :
    toCoalgebraCatIso e.symm = (toCoalgebraCatIso e).symm 
goal: e.symm.toCoalgebraCatIso = e.toCoalgebraCatIso.symm

full_name: CoalgEquiv.toCoalgebraCatIso_trans
code: @[simp] theorem toCoalgebraCatIso_trans (e : X ≃ₗc[R] Y) (f : Y ≃ₗc[R] Z) :
    toCoalgebraCatIso (e.trans f) = toCoalgebraCatIso e ≪≫ toCoalgebraCatIso f 
goal: (e.trans f).toCoalgebraCatIso = e.toCoalgebraCatIso ≪≫ f.toCoalgebraCatIso

full_name: CategoryTheory.Iso.toCoalgEquiv
code: /-- Build a `CoalgEquiv` from an isomorphism in the category
`CoalgebraCat R`. -/
def toCoalgEquiv (i : X ≅ Y) : X ≃ₗc[R] Y 
goal: ↑X.toModuleCat ≃ₗc[R] ↑Y.toModuleCat

full_name: CategoryTheory.Iso.toCoalgEquiv_toCoalgHom
code: @[simp] theorem toCoalgEquiv_toCoalgHom (i : X ≅ Y) :
    i.toCoalgEquiv = i.hom.toCoalgHom 
goal: ↑i.toCoalgEquiv = i.hom.toCoalgHom

full_name: CategoryTheory.Iso.toCoalgEquiv_refl
code: @[simp] theorem toCoalgEquiv_refl : toCoalgEquiv (.refl X) = .refl _ _ 
goal: (CategoryTheory.Iso.refl X).toCoalgEquiv = CoalgEquiv.refl R ↑X.toModuleCat

full_name: CategoryTheory.Iso.toCoalgEquiv_symm
code: @[simp] theorem toCoalgEquiv_symm (e : X ≅ Y) :
    toCoalgEquiv e.symm = (toCoalgEquiv e).symm 
goal: e.symm.toCoalgEquiv = e.toCoalgEquiv.symm

full_name: CategoryTheory.Iso.toCoalgEquiv_trans
code: @[simp] theorem toCoalgEquiv_trans (e : X ≅ Y) (f : Y ≅ Z) :
    toCoalgEquiv (e ≪≫ f) = e.toCoalgEquiv.trans f.toCoalgEquiv 
goal: (e ≪≫ f).toCoalgEquiv = e.toCoalgEquiv.trans f.toCoalgEquiv

full_name: CoalgebraCat.forget_reflects_isos
code: instance CoalgebraCat.forget_reflects_isos :
    (forget (CoalgebraCat.{v} R)).ReflectsIsomorphisms 
goal: (CategoryTheory.forget (CoalgebraCat R)).ReflectsIsomorphisms