Category instance for algebras over a commutative ring

We introduce the bundled category AlgebraCat of algebras over a fixed commutative ring R along with the forgetful functors to RingCat and ModuleCat. We furthermore show that the functor associating to a type the free R-algebra on that type is left adjoint to the forgetful functor.

structure AlgebraCat (R : Type u) [CommRing R] : Type (max u (v + 1))

The category of R-algebras and their morphisms.

• carrier : Type v
• isRing : Ring ↑self
• isAlgebra : Algebra R ↑self

@[inline, reducible]

abbrev AlgebraCatMax (R : Type u₁) [CommRing R] : Type (max u₁ ((max v₁ v₂) + 1))

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.

Equations

• AlgebraCatMax R = AlgebraCat R

instance AlgebraCat.instCoeSortAlgebraCatType (R : Type u) [CommRing R] : CoeSort (AlgebraCat R) (Type v)

Equations

• AlgebraCat.instCoeSortAlgebraCatType R = { coe := AlgebraCat.carrier }

instance AlgebraCat.instCategoryAlgebraCat (R : Type u) [CommRing R] : CategoryTheory.Category.{v, max (v + 1) u} (AlgebraCat R)

Equations

• AlgebraCat.instCategoryAlgebraCat R = CategoryTheory.Category.mk

instance AlgebraCat.instFunLikeHomAlgebraCatToQuiverToCategoryStructInstCategoryAlgebraCatCarrier (R : Type u) [CommRing R] {M : AlgebraCat R} {N : AlgebraCat R} : FunLike (M ⟶ N) ↑M ↑N

Equations

• AlgebraCat.instFunLikeHomAlgebraCatToQuiverToCategoryStructInstCategoryAlgebraCatCarrier R = AlgHom.funLike

instance AlgebraCat.instAlgHomClassHomAlgebraCatToQuiverToCategoryStructInstCategoryAlgebraCatCarrierToCommSemiringToSemiringIsRingIsAlgebraInstFunLikeHomAlgebraCatToQuiverToCategoryStructInstCategoryAlgebraCatCarrier (R : Type u) [CommRing R] {M : AlgebraCat R} {N : AlgebraCat R} : AlgHomClass (M ⟶ N) R ↑M ↑N

Equations

• (_ : AlgHomClass (M ⟶ N) R ↑M ↑N) = (_ : AlgHomClass (↑M →ₐ[R] ↑N) R ↑M ↑N)

instance AlgebraCat.instConcreteCategoryAlgebraCatInstCategoryAlgebraCat (R : Type u) [CommRing R] : CategoryTheory.ConcreteCategory (AlgebraCat R)

Equations

• One or more equations did not get rendered due to their size.

instance AlgebraCat.instRingObjAlgebraCatToQuiverToCategoryStructInstCategoryAlgebraCatTypeToQuiverToCategoryStructTypesToPrefunctorForgetInstConcreteCategoryAlgebraCatInstCategoryAlgebraCat (R : Type u) [CommRing R] {S : AlgebraCat R} : Ring ((CategoryTheory.forget (AlgebraCat R)).toPrefunctor.obj S)

Equations

• One or more equations did not get rendered due to their size.

instance AlgebraCat.instAlgebraObjAlgebraCatToQuiverToCategoryStructInstCategoryAlgebraCatTypeToQuiverToCategoryStructTypesToPrefunctorForgetInstConcreteCategoryAlgebraCatInstCategoryAlgebraCatToCommSemiringToSemiringInstRingObjAlgebraCatToQuiverToCategoryStructInstCategoryAlgebraCatTypeToQuiverToCategoryStructTypesToPrefunctorForgetInstConcreteCategoryAlgebraCatInstCategoryAlgebraCat (R : Type u) [CommRing R] {S : AlgebraCat R} : Algebra R ((CategoryTheory.forget (AlgebraCat R)).toPrefunctor.obj S)

Equations

• One or more equations did not get rendered due to their size.

instance AlgebraCat.hasForgetToRing (R : Type u) [CommRing R] : CategoryTheory.HasForget₂ (AlgebraCat R) RingCat

Equations

• One or more equations did not get rendered due to their size.

instance AlgebraCat.hasForgetToModule (R : Type u) [CommRing R] : CategoryTheory.HasForget₂ (AlgebraCat R) (ModuleCat R)

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem AlgebraCat.forget₂_module_obj (R : Type u) [CommRing R] (X : AlgebraCat R) : (CategoryTheory.forget₂ (AlgebraCat R) (ModuleCat R)).toPrefunctor.obj X = ModuleCat.of R ↑X

@[simp]

theorem AlgebraCat.forget₂_module_map (R : Type u) [CommRing R] {X : AlgebraCat R} {Y : AlgebraCat R} (f : X ⟶ Y) : (CategoryTheory.forget₂ (AlgebraCat R) (ModuleCat R)).toPrefunctor.map f = ModuleCat.ofHom (AlgHom.toLinearMap f)

def AlgebraCat.of (R : Type u) [CommRing R] (X : Type v) [Ring X] [Algebra R X] : AlgebraCat R

The object in the category of R-algebras associated to a type equipped with the appropriate typeclasses.

Equations

• AlgebraCat.of R X = AlgebraCat.mk X

def AlgebraCat.ofHom {R : Type u} [CommRing R] {X : Type v} {Y : Type v} [Ring X] [Algebra R X] [Ring Y] [Algebra R Y] (f : X →ₐ[R] Y) : AlgebraCat.of R X ⟶ AlgebraCat.of R Y

Typecheck a AlgHom as a morphism in AlgebraCat R.

Equations

• AlgebraCat.ofHom f = f

@[simp]

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

instance AlgebraCat.instInhabitedAlgebraCat (R : Type u) [CommRing R] : Inhabited (AlgebraCat R)

Equations

• AlgebraCat.instInhabitedAlgebraCat R = { default := AlgebraCat.of R R }

@[simp]

theorem AlgebraCat.coe_of (R : Type u) [CommRing R] (X : Type u) [Ring X] [Algebra R X] : ↑(AlgebraCat.of R X) = X

@[simp]

theorem AlgebraCat.ofSelfIso_hom {R : Type u} [CommRing R] (M : AlgebraCat R) : (AlgebraCat.ofSelfIso M).hom = CategoryTheory.CategoryStruct.id M

@[simp]

theorem AlgebraCat.ofSelfIso_inv {R : Type u} [CommRing R] (M : AlgebraCat R) : (AlgebraCat.ofSelfIso M).inv = CategoryTheory.CategoryStruct.id M

def AlgebraCat.ofSelfIso {R : Type u} [CommRing R] (M : AlgebraCat R) : AlgebraCat.of R ↑M ≅ M

Forgetting to the underlying type and then building the bundled object returns the original algebra.

Equations

• AlgebraCat.ofSelfIso M = CategoryTheory.Iso.mk (CategoryTheory.CategoryStruct.id M) (CategoryTheory.CategoryStruct.id M)

@[simp]

theorem AlgebraCat.id_apply {R : Type u} [CommRing R] {M : ModuleCat R} (m : ↑M) : (CategoryTheory.CategoryStruct.id M) m = m

@[simp]

theorem AlgebraCat.coe_comp {R : Type u} [CommRing R] {M : ModuleCat R} {N : ModuleCat R} {U : ModuleCat R} (f : M ⟶ N) (g : N ⟶ U) : ⇑(CategoryTheory.CategoryStruct.comp f g) = ⇑g ∘ ⇑f

@[simp]

theorem AlgebraCat.free_map (R : Type u) [CommRing R] : ∀ {X Y : Type u} (f : X ⟶ Y), (AlgebraCat.free R).toPrefunctor.map f = (FreeAlgebra.lift R) (FreeAlgebra.ι R ∘ f)

@[simp]

theorem AlgebraCat.free_obj_carrier (R : Type u) [CommRing R] (S : Type u) : ↑((AlgebraCat.free R).toPrefunctor.obj S) = FreeAlgebra R S

def AlgebraCat.free (R : Type u) [CommRing R] : CategoryTheory.Functor (Type u) (AlgebraCat R)

The "free algebra" functor, sending a type S to the free algebra on S.

Equations

• One or more equations did not get rendered due to their size.

def AlgebraCat.adj (R : Type u) [CommRing R] : AlgebraCat.free R ⊣ CategoryTheory.forget (AlgebraCat R)

The free/forget adjunction for R-algebras.

Equations

• AlgebraCat.adj R = CategoryTheory.Adjunction.mkOfHomEquiv (CategoryTheory.Adjunction.CoreHomEquiv.mk fun (X : Type u) (A : AlgebraCat R) => (FreeAlgebra.lift R).symm)

instance AlgebraCat.instIsRightAdjointTypeTypesAlgebraCatInstCategoryAlgebraCatForgetInstConcreteCategoryAlgebraCatInstCategoryAlgebraCat (R : Type u) [CommRing R] : CategoryTheory.IsRightAdjoint (CategoryTheory.forget (AlgebraCat R))

Equations

• AlgebraCat.instIsRightAdjointTypeTypesAlgebraCatInstCategoryAlgebraCatForgetInstConcreteCategoryAlgebraCatInstCategoryAlgebraCat R = { left := AlgebraCat.free R, adj := AlgebraCat.adj R }

@[simp]

theorem AlgEquiv.toAlgebraIso_hom {R : Type u} [CommRing R] {X₁ : Type u} {X₂ : Type u} {g₁ : Ring X₁} {g₂ : Ring X₂} {m₁ : Algebra R X₁} {m₂ : Algebra R X₂} (e : X₁ ≃ₐ[R] X₂) : (AlgEquiv.toAlgebraIso e).hom = ↑e

@[simp]

theorem AlgEquiv.toAlgebraIso_inv {R : Type u} [CommRing R] {X₁ : Type u} {X₂ : Type u} {g₁ : Ring X₁} {g₂ : Ring X₂} {m₁ : Algebra R X₁} {m₂ : Algebra R X₂} (e : X₁ ≃ₐ[R] X₂) : (AlgEquiv.toAlgebraIso e).inv = ↑(AlgEquiv.symm e)

def AlgEquiv.toAlgebraIso {R : Type u} [CommRing R] {X₁ : Type u} {X₂ : Type u} {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₂

Build an isomorphism in the category AlgebraCat R from a AlgEquiv between Algebras.

Equations

• AlgEquiv.toAlgebraIso e = CategoryTheory.Iso.mk ↑e ↑(AlgEquiv.symm e)

@[simp]

theorem CategoryTheory.Iso.toAlgEquiv_apply {R : Type u} [CommRing R] {X : AlgebraCat R} {Y : AlgebraCat R} (i : X ≅ Y) (a : ↑X) : (CategoryTheory.Iso.toAlgEquiv i) a = i.hom a

@[simp]

theorem CategoryTheory.Iso.toAlgEquiv_symm_apply {R : Type u} [CommRing R] {X : AlgebraCat R} {Y : AlgebraCat R} (i : X ≅ Y) (a : ↑Y) : (AlgEquiv.symm (CategoryTheory.Iso.toAlgEquiv i)) a = i.inv a

def CategoryTheory.Iso.toAlgEquiv {R : Type u} [CommRing R] {X : AlgebraCat R} {Y : AlgebraCat R} (i : X ≅ Y) : ↑X ≃ₐ[R] ↑Y

Build a AlgEquiv from an isomorphism in the category AlgebraCat R.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem algEquivIsoAlgebraIso_hom {R : Type u} [CommRing R] {X : Type u} {Y : Type u} [Ring X] [Ring Y] [Algebra R X] [Algebra R Y] (e : X ≃ₐ[R] Y) : algEquivIsoAlgebraIso.hom e = AlgEquiv.toAlgebraIso e

@[simp]

theorem algEquivIsoAlgebraIso_inv {R : Type u} [CommRing R] {X : Type u} {Y : Type u} [Ring X] [Ring Y] [Algebra R X] [Algebra R Y] (i : AlgebraCat.of R X ≅ AlgebraCat.of R Y) : algEquivIsoAlgebraIso.inv i = CategoryTheory.Iso.toAlgEquiv i

def algEquivIsoAlgebraIso {R : Type u} [CommRing R] {X : Type u} {Y : Type u} [Ring X] [Ring Y] [Algebra R X] [Algebra R Y] : (X ≃ₐ[R] Y) ≅ AlgebraCat.of R X ≅ AlgebraCat.of R Y

Algebra equivalences between Algebras are the same as (isomorphic to) isomorphisms in AlgebraCat.

Equations

• algEquivIsoAlgebraIso = CategoryTheory.Iso.mk (fun (e : X ≃ₐ[R] Y) => AlgEquiv.toAlgebraIso e) fun (i : AlgebraCat.of R X ≅ AlgebraCat.of R Y) => CategoryTheory.Iso.toAlgEquiv i

instance instCoeOutSubalgebraToCommSemiringToSemiringAlgebraCat {R : Type u} [CommRing R] (X : Type u) [Ring X] [Algebra R X] : CoeOut (Subalgebra R X) (AlgebraCat R)

Equations

• instCoeOutSubalgebraToCommSemiringToSemiringAlgebraCat X = { coe := fun (N : Subalgebra R X) => AlgebraCat.of R ↥N }

instance AlgebraCat.forget_reflects_isos {R : Type u} [CommRing R] : CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget (AlgebraCat R))

Equations

• (_ : CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget (AlgebraCat R))) = (_ : CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget (AlgebraCat R)))