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

full_name: AlgebraCat.isAlgebra
code: /-- The category of R-algebras and their morphisms. -/
structure AlgebraCat where
  carrier : Type v
  [isRing : Ring carrier]
  [isAlgebra : Algebra R carrier]
goal: Algebra R ↑self

full_name: AlgebraCat.carrier
code: /-- The category of R-algebras and their morphisms. -/
structure AlgebraCat where
  carrier : Type v
  [isRing : Ring carrier]
  [isAlgebra : Algebra R carrier]
goal: Type v

full_name: AlgebraCat.isRing
code: /-- The category of R-algebras and their morphisms. -/
structure AlgebraCat where
  carrier : Type v
  [isRing : Ring carrier]
  [isAlgebra : Algebra R carrier]
goal: Ring ↑self

full_name: AlgebraCat
code: /-- The category of R-algebras and their morphisms. -/
structure AlgebraCat where
  carrier : Type v
  [isRing : Ring carrier]
  [isAlgebra : Algebra R carrier]
goal: Type (max u (v + 1))

full_name: AlgebraCatMax
code: /-- An alias for `AlgebraCat.{max u₁ u₂}`, to deal around unification issues.
Since the universe the ring lives in can be inferred, we put that last. -/
@[nolint checkUnivs]
abbrev AlgebraCatMax.{v₁, v₂, u₁} (R : Type u₁) [CommRing R] 
goal: Type (max u₁ ((max v₁ v₂) + 1))

full_name: AlgebraCat.instCoeSortType
code: instance : CoeSort (AlgebraCat R) (Type v) 
goal: CoeSort (AlgebraCat R) (Type v)

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

full_name: AlgebraCat.instFunLikeHomCarrier
code: instance {M N : AlgebraCat.{v} R} : FunLike (M ⟶ N) M N 
goal: FunLike (M ⟶ N) ↑M ↑N

full_name: AlgebraCat.instAlgHomClassHomCarrier
code: instance {M N : AlgebraCat.{v} R} : AlgHomClass (M ⟶ N) R M N 
goal: AlgHomClass (M ⟶ N) R ↑M ↑N

full_name: AlgebraCat.instConcreteCategory
code: instance : ConcreteCategory.{v} (AlgebraCat.{v} R) 
goal: CategoryTheory.ConcreteCategory (AlgebraCat R)

full_name: AlgebraCat.instRingObjForget
code: instance {S : AlgebraCat.{v} R} : Ring ((forget (AlgebraCat R)).obj S) 
goal: Ring ((CategoryTheory.forget (AlgebraCat R)).obj S)

full_name: AlgebraCat.instAlgebraObjForget
code: instance {S : AlgebraCat.{v} R} : Algebra R ((forget (AlgebraCat R)).obj S) 
goal: Algebra R ((CategoryTheory.forget (AlgebraCat R)).obj S)

full_name: AlgebraCat.hasForgetToRing
code: instance hasForgetToRing : HasForget₂ (AlgebraCat.{v} R) RingCat.{v} 
goal: CategoryTheory.HasForget₂ (AlgebraCat R) RingCat

full_name: AlgebraCat.hasForgetToModule
code: instance hasForgetToModule : HasForget₂ (AlgebraCat.{v} R) (ModuleCat.{v} R) 
goal: CategoryTheory.HasForget₂ (AlgebraCat R) (ModuleCat R)

full_name: AlgebraCat.forget₂_module_obj
code: @[simp]
lemma forget₂_module_obj (X : AlgebraCat.{v} R) :
    (forget₂ (AlgebraCat.{v} R) (ModuleCat.{v} R)).obj X = ModuleCat.of R X 
goal: (CategoryTheory.forget₂ (AlgebraCat R) (ModuleCat R)).obj X = ModuleCat.of R ↑X

full_name: AlgebraCat.forget₂_module_map
code: @[simp]
lemma forget₂_module_map {X Y : AlgebraCat.{v} R} (f : X ⟶ Y) :
    (forget₂ (AlgebraCat.{v} R) (ModuleCat.{v} R)).map f = ModuleCat.ofHom f.toLinearMap 
goal: (CategoryTheory.forget₂ (AlgebraCat R) (ModuleCat R)).map f = ModuleCat.ofHom (AlgHom.toLinearMap f)

full_name: AlgebraCat.of
code: /-- The object in the category of R-algebras associated to a type equipped with the appropriate
typeclasses. -/
def of (X : Type v) [Ring X] [Algebra R X] : AlgebraCat.{v} R 
goal: AlgebraCat R

full_name: AlgebraCat.ofHom
code: /-- Typecheck a `AlgHom` as a morphism in `AlgebraCat R`. -/
def ofHom {R : Type u} [CommRing R] {X Y : Type v} [Ring X] [Algebra R X] [Ring Y] [Algebra R Y]
    (f : X →ₐ[R] Y) : of R X ⟶ of R Y 
goal: AlgebraCat.of R X ⟶ AlgebraCat.of R Y

full_name: AlgebraCat.ofHom_apply
code: @[simp]
theorem ofHom_apply {R : Type u} [CommRing R] {X Y : Type v} [Ring X] [Algebra R X] [Ring Y]
    [Algebra R Y] (f : X →ₐ[R] Y) (x : X) : ofHom f x = f x 
goal: (AlgebraCat.ofHom f) x = f x

full_name: AlgebraCat.instInhabited
code: instance : Inhabited (AlgebraCat R) 
goal: Inhabited (AlgebraCat R)

full_name: AlgebraCat.coe_of
code: @[simp]
theorem coe_of (X : Type u) [Ring X] [Algebra R X] : (of R X : Type u) = X 
goal: ↑(AlgebraCat.of R X) = X

full_name: AlgebraCat.ofSelfIso_inv
code: /-- Forgetting to the underlying type and then building the bundled object returns the original
algebra. -/
@[simps]
def ofSelfIso (M : AlgebraCat.{v} R) : AlgebraCat.of R M ≅ M 
goal: M.ofSelfIso.inv = 𝟙 M

full_name: AlgebraCat.ofSelfIso
code: /-- Forgetting to the underlying type and then building the bundled object returns the original
algebra. -/
@[simps]
def ofSelfIso (M : AlgebraCat.{v} R) : AlgebraCat.of R M ≅ M 
goal: AlgebraCat.of R ↑M ≅ M

full_name: AlgebraCat.ofSelfIso_hom
code: /-- Forgetting to the underlying type and then building the bundled object returns the original
algebra. -/
@[simps]
def ofSelfIso (M : AlgebraCat.{v} R) : AlgebraCat.of R M ≅ M 
goal: M.ofSelfIso.hom = 𝟙 M

full_name: AlgebraCat.id_apply
code: @[simp]
theorem id_apply (m : M) : (𝟙 M : M → M) m = m 
goal: (𝟙 M) m = m

full_name: AlgebraCat.coe_comp
code: @[simp]
theorem coe_comp (f : M ⟶ N) (g : N ⟶ U) : (f ≫ g : M → U) = g ∘ f 
goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f

full_name: AlgebraCat.free_map
code: /-- The "free algebra" functor, sending a type `S` to the free algebra on `S`. -/
@[simps!]
def free : Type u ⥤ AlgebraCat.{u} R 
goal: ∀ {X Y : Type u} (f : X ⟶ Y), (AlgebraCat.free R).map f = (FreeAlgebra.lift R) (FreeAlgebra.ι R ∘ f)

full_name: AlgebraCat.free
code: /-- The "free algebra" functor, sending a type `S` to the free algebra on `S`. -/
@[simps!]
def free : Type u ⥤ AlgebraCat.{u} R 
goal: Type u ⥤ AlgebraCat R

full_name: AlgebraCat.free_obj_carrier
code: /-- The "free algebra" functor, sending a type `S` to the free algebra on `S`. -/
@[simps!]
def free : Type u ⥤ AlgebraCat.{u} R 
goal: ↑((AlgebraCat.free R).obj S) = FreeAlgebra R S

full_name: AlgebraCat.adj
code: /-- The free/forget adjunction for `R`-algebras. -/
def adj : free.{u} R ⊣ forget (AlgebraCat.{u} R) 
goal: AlgebraCat.free R ⊣ CategoryTheory.forget (AlgebraCat R)

full_name: AlgebraCat.instIsRightAdjointForget
code: instance : (forget (AlgebraCat.{u} R)).IsRightAdjoint 
goal: (CategoryTheory.forget (AlgebraCat R)).IsRightAdjoint

full_name: AlgEquiv.toAlgebraIso_hom
code: /-- Build an isomorphism in the category `AlgebraCat R` from a `AlgEquiv` between `Algebra`s. -/
@[simps]
def AlgEquiv.toAlgebraIso {g₁ : Ring X₁} {g₂ : Ring X₂} {m₁ : Algebra R X₁} {m₂ : Algebra R X₂}
    (e : X₁ ≃ₐ[R] X₂) : AlgebraCat.of R X₁ ≅ AlgebraCat.of R X₂ 
goal: e.toAlgebraIso.hom = ↑e

full_name: AlgEquiv.toAlgebraIso
code: /-- Build an isomorphism in the category `AlgebraCat R` from a `AlgEquiv` between `Algebra`s. -/
@[simps]
def AlgEquiv.toAlgebraIso {g₁ : Ring X₁} {g₂ : Ring X₂} {m₁ : Algebra R X₁} {m₂ : Algebra R X₂}
    (e : X₁ ≃ₐ[R] X₂) : AlgebraCat.of R X₁ ≅ AlgebraCat.of R X₂ 
goal: AlgebraCat.of R X₁ ≅ AlgebraCat.of R X₂

full_name: AlgEquiv.toAlgebraIso_inv
code: /-- Build an isomorphism in the category `AlgebraCat R` from a `AlgEquiv` between `Algebra`s. -/
@[simps]
def AlgEquiv.toAlgebraIso {g₁ : Ring X₁} {g₂ : Ring X₂} {m₁ : Algebra R X₁} {m₂ : Algebra R X₂}
    (e : X₁ ≃ₐ[R] X₂) : AlgebraCat.of R X₁ ≅ AlgebraCat.of R X₂ 
goal: e.toAlgebraIso.inv = ↑e.symm

full_name: CategoryTheory.Iso.toAlgEquiv_apply
code: /-- Build a `AlgEquiv` from an isomorphism in the category `AlgebraCat R`. -/
@[simps]
def toAlgEquiv {X Y : AlgebraCat R} (i : X ≅ Y) : X ≃ₐ[R] Y 
goal: i.toAlgEquiv a = i.hom a

full_name: CategoryTheory.Iso.toAlgEquiv
code: /-- Build a `AlgEquiv` from an isomorphism in the category `AlgebraCat R`. -/
@[simps]
def toAlgEquiv {X Y : AlgebraCat R} (i : X ≅ Y) : X ≃ₐ[R] Y 
goal: ↑X ≃ₐ[R] ↑Y

full_name: CategoryTheory.Iso.toAlgEquiv_symm_apply
code: /-- Build a `AlgEquiv` from an isomorphism in the category `AlgebraCat R`. -/
@[simps]
def toAlgEquiv {X Y : AlgebraCat R} (i : X ≅ Y) : X ≃ₐ[R] Y 
goal: i.toAlgEquiv.symm a = i.inv a

full_name: algEquivIsoAlgebraIso_inv
code: /-- Algebra equivalences between `Algebra`s are the same as (isomorphic to) isomorphisms in
`AlgebraCat`. -/
@[simps]
def algEquivIsoAlgebraIso {X Y : Type u} [Ring X] [Ring Y] [Algebra R X] [Algebra R Y] :
    (X ≃ₐ[R] Y) ≅ AlgebraCat.of R X ≅ AlgebraCat.of R Y 
goal: algEquivIsoAlgebraIso.inv i = i.toAlgEquiv

full_name: algEquivIsoAlgebraIso_hom
code: /-- Algebra equivalences between `Algebra`s are the same as (isomorphic to) isomorphisms in
`AlgebraCat`. -/
@[simps]
def algEquivIsoAlgebraIso {X Y : Type u} [Ring X] [Ring Y] [Algebra R X] [Algebra R Y] :
    (X ≃ₐ[R] Y) ≅ AlgebraCat.of R X ≅ AlgebraCat.of R Y 
goal: algEquivIsoAlgebraIso.hom e = e.toAlgebraIso

full_name: algEquivIsoAlgebraIso
code: /-- Algebra equivalences between `Algebra`s are the same as (isomorphic to) isomorphisms in
`AlgebraCat`. -/
@[simps]
def algEquivIsoAlgebraIso {X Y : Type u} [Ring X] [Ring Y] [Algebra R X] [Algebra R Y] :
    (X ≃ₐ[R] Y) ≅ AlgebraCat.of R X ≅ AlgebraCat.of R Y 
goal: (X ≃ₐ[R] Y) ≅ AlgebraCat.of R X ≅ AlgebraCat.of R Y

full_name: AlgebraCat.forget_reflects_isos
code: instance AlgebraCat.forget_reflects_isos : (forget (AlgebraCat.{u} R)).ReflectsIsomorphisms 
goal: (CategoryTheory.forget (AlgebraCat R)).ReflectsIsomorphisms

full_name: AlgHom.comp_id_algebraCat
code: @[simp] theorem AlgHom.comp_id_algebraCat
    {R} [CommRing R] {G : AlgebraCat.{u} R} {H : Type u} [Ring H] [Algebra R H] (f : G →ₐ[R] H) :
    f.comp (𝟙 G) = f 
goal: f.comp (𝟙 G) = f

full_name: AlgHom.id_algebraCat_comp
code: @[simp] theorem AlgHom.id_algebraCat_comp
    {R} [CommRing R] {G : Type u} [Ring G] [Algebra R G] {H : AlgebraCat.{u} R} (f : G →ₐ[R] H) :
    AlgHom.comp (𝟙 H) f = f 
goal: AlgHom.comp (𝟙 H) f = f