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

full_name: BialgebraCat.instBialgebra
code: /-- The category of `R`-bialgebras. -/
structure BialgebraCat extends Bundled Ring.{v} where
  [instBialgebra : Bialgebra R α]
goal: Bialgebra R ↑self.toBundled

full_name: BialgebraCat
code: /-- The category of `R`-bialgebras. -/
structure BialgebraCat extends Bundled Ring.{v} where
  [instBialgebra : Bialgebra R α]
goal: Type (max u (v + 1))

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

full_name: BialgebraCat.of_instBialgebra
code: /-- The object in the category of `R`-bialgebras associated to an `R`-bialgebra. -/
@[simps]
def of (X : Type v) [Ring X] [Bialgebra R X] :
    BialgebraCat R 
goal: (BialgebraCat.of R X).instBialgebra = inferInstance

full_name: BialgebraCat.of_str
code: /-- The object in the category of `R`-bialgebras associated to an `R`-bialgebra. -/
@[simps]
def of (X : Type v) [Ring X] [Bialgebra R X] :
    BialgebraCat R 
goal: (BialgebraCat.of R X).str = inferInstance

full_name: BialgebraCat.of
code: /-- The object in the category of `R`-bialgebras associated to an `R`-bialgebra. -/
@[simps]
def of (X : Type v) [Ring X] [Bialgebra R X] :
    BialgebraCat R 
goal: BialgebraCat R

full_name: BialgebraCat.of_α
code: /-- The object in the category of `R`-bialgebras associated to an `R`-bialgebra. -/
@[simps]
def of (X : Type v) [Ring X] [Bialgebra R X] :
    BialgebraCat R 
goal: ↑(BialgebraCat.of R X).toBundled = X

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

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

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

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

full_name: BialgebraCat.Hom.toBialgHom_injective
code: lemma Hom.toBialgHom_injective (V W : BialgebraCat.{v} R) :
    Function.Injective (Hom.toBialgHom : Hom V W → _) 
goal: Function.Injective BialgebraCat.Hom.toBialgHom

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

full_name: BialgebraCat.hom_ext
code: @[ext]
lemma hom_ext {X Y : BialgebraCat.{v} R} (f g : X ⟶ Y) (h : f.toBialgHom = g.toBialgHom) :
    f = g 
goal: f = g

full_name: BialgebraCat.ofHom
code: /-- Typecheck a `BialgHom` as a morphism in `BialgebraCat R`. -/
abbrev ofHom {X Y : Type v} [Ring X] [Ring Y]
    [Bialgebra R X] [Bialgebra R Y] (f : X →ₐc[R] Y) :
    of R X ⟶ of R Y 
goal: BialgebraCat.of R X ⟶ BialgebraCat.of R Y

full_name: BialgebraCat.toBialgHom_comp
code: @[simp] theorem toBialgHom_comp {X Y Z : BialgebraCat.{v} R} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).toBialgHom = g.toBialgHom.comp f.toBialgHom 
goal: (f ≫ g).toBialgHom = g.toBialgHom.comp f.toBialgHom

full_name: BialgebraCat.toBialgHom_id
code: @[simp] theorem toBialgHom_id {M : BialgebraCat.{v} R} :
    Hom.toBialgHom (𝟙 M) = BialgHom.id _ _ 
goal: (𝟙 M).toBialgHom = BialgHom.id R ↑M.toBundled

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

full_name: BialgebraCat.hasForgetToAlgebra
code: instance hasForgetToAlgebra : HasForget₂ (BialgebraCat R) (AlgebraCat R) 
goal: CategoryTheory.HasForget₂ (BialgebraCat R) (AlgebraCat R)

full_name: BialgebraCat.forget₂_algebra_obj
code: @[simp]
theorem forget₂_algebra_obj (X : BialgebraCat R) :
    (forget₂ (BialgebraCat R) (AlgebraCat R)).obj X = AlgebraCat.of R X 
goal: (CategoryTheory.forget₂ (BialgebraCat R) (AlgebraCat R)).obj X = AlgebraCat.of R ↑X.toBundled

full_name: BialgebraCat.forget₂_algebra_map
code: @[simp]
theorem forget₂_algebra_map (X Y : BialgebraCat R) (f : X ⟶ Y) :
    (forget₂ (BialgebraCat R) (AlgebraCat R)).map f = (f.toBialgHom : X →ₐ[R] Y) 
goal: (CategoryTheory.forget₂ (BialgebraCat R) (AlgebraCat R)).map f = ↑f.toBialgHom

full_name: BialgebraCat.hasForgetToCoalgebra
code: instance hasForgetToCoalgebra : HasForget₂ (BialgebraCat R) (CoalgebraCat R) 
goal: CategoryTheory.HasForget₂ (BialgebraCat R) (CoalgebraCat R)

full_name: BialgebraCat.forget₂_coalgebra_obj
code: @[simp]
theorem forget₂_coalgebra_obj (X : BialgebraCat R) :
    (forget₂ (BialgebraCat R) (CoalgebraCat R)).obj X = CoalgebraCat.of R X 
goal: (CategoryTheory.forget₂ (BialgebraCat R) (CoalgebraCat R)).obj X = CoalgebraCat.of R ↑X.toBundled

full_name: BialgebraCat.forget₂_coalgebra_map
code: @[simp]
theorem forget₂_coalgebra_map (X Y : BialgebraCat R) (f : X ⟶ Y) :
    (forget₂ (BialgebraCat R) (CoalgebraCat R)).map f = CoalgebraCat.ofHom f.toBialgHom 
goal: (CategoryTheory.forget₂ (BialgebraCat R) (CoalgebraCat R)).map f = CoalgebraCat.ofHom ↑f.toBialgHom

full_name: BialgEquiv.toBialgebraCatIso_hom_toBialgHom
code: /-- Build an isomorphism in the category `BialgebraCat R` from a
`BialgEquiv`. -/
@[simps]
def toBialgebraCatIso (e : X ≃ₐc[R] Y) : BialgebraCat.of R X ≅ BialgebraCat.of R Y 
goal: e.toBialgebraCatIso.hom.toBialgHom = ↑e

full_name: BialgEquiv.toBialgebraCatIso_inv_toBialgHom
code: /-- Build an isomorphism in the category `BialgebraCat R` from a
`BialgEquiv`. -/
@[simps]
def toBialgebraCatIso (e : X ≃ₐc[R] Y) : BialgebraCat.of R X ≅ BialgebraCat.of R Y 
goal: e.toBialgebraCatIso.inv.toBialgHom = ↑e.symm

full_name: BialgEquiv.toBialgebraCatIso
code: /-- Build an isomorphism in the category `BialgebraCat R` from a
`BialgEquiv`. -/
@[simps]
def toBialgebraCatIso (e : X ≃ₐc[R] Y) : BialgebraCat.of R X ≅ BialgebraCat.of R Y 
goal: BialgebraCat.of R X ≅ BialgebraCat.of R Y

full_name: BialgEquiv.toBialgebraCatIso_refl
code: @[simp] theorem toBialgebraCatIso_refl : toBialgebraCatIso (BialgEquiv.refl R X) = .refl _ 
goal: (BialgEquiv.refl R X).toBialgebraCatIso = CategoryTheory.Iso.refl (BialgebraCat.of R X)

full_name: BialgEquiv.toBialgebraCatIso_symm
code: @[simp] theorem toBialgebraCatIso_symm (e : X ≃ₐc[R] Y) :
    toBialgebraCatIso e.symm = (toBialgebraCatIso e).symm 
goal: e.symm.toBialgebraCatIso = e.toBialgebraCatIso.symm

full_name: BialgEquiv.toBialgebraCatIso_trans
code: @[simp] theorem toBialgebraCatIso_trans (e : X ≃ₐc[R] Y) (f : Y ≃ₐc[R] Z) :
    toBialgebraCatIso (e.trans f) = toBialgebraCatIso e ≪≫ toBialgebraCatIso f 
goal: (e.trans f).toBialgebraCatIso = e.toBialgebraCatIso ≪≫ f.toBialgebraCatIso

full_name: CategoryTheory.Iso.toBialgEquiv
code: /-- Build a `BialgEquiv` from an isomorphism in the category
`BialgebraCat R`. -/
def toBialgEquiv (i : X ≅ Y) : X ≃ₐc[R] Y 
goal: ↑X.toBundled ≃ₐc[R] ↑Y.toBundled

full_name: CategoryTheory.Iso.toBialgEquiv_toBialgHom
code: @[simp] theorem toBialgEquiv_toBialgHom (i : X ≅ Y) :
    (i.toBialgEquiv : X →ₐc[R] Y) = i.hom.1 
goal: ↑i.toBialgEquiv = i.hom.toBialgHom

full_name: CategoryTheory.Iso.toBialgEquiv_refl
code: @[simp] theorem toBialgEquiv_refl : toBialgEquiv (.refl X) = .refl _ _ 
goal: (CategoryTheory.Iso.refl X).toBialgEquiv = BialgEquiv.refl R ↑X.toBundled

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

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

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