The category of commutative algebras over a commutative ring

This file defines the bundled category CommAlgCat of commutative algebras over a fixed commutative ring R along with the forgetful functors to CommRingCat and AlgCat.

structure CategoryTheory.CommAlgCat (R : Type u) [CommRing R] : Type (max u (v + 1))

The category of R-algebras and their morphisms.

• carrier : Type v

  The underlying type.

• commRing : CommRing ↑self
• algebra : Algebra R ↑self

instance CategoryTheory.CommAlgCat.instCoeSortType {R : Type u} [CommRing R] : CoeSort (CommAlgCat R) (Type v)

Equations

• CategoryTheory.CommAlgCat.instCoeSortType = { coe := CategoryTheory.CommAlgCat.carrier }

@[reducible, inline]

abbrev CategoryTheory.CommAlgCat.of (R : Type u) [CommRing R] (X : Type v) [CommRing X] [Algebra R X] : CommAlgCat R

The object in the category of R-algebras associated to a type equipped with the appropriate typeclasses. This is the preferred way to construct a term of CommAlgCat R.

Equations

• CategoryTheory.CommAlgCat.of R X = { carrier := X, commRing := inst✝¹, algebra := inst✝ }

theorem CategoryTheory.CommAlgCat.coe_of (R : Type u) [CommRing R] (X : Type v) [CommRing X] [Algebra R X] : ↑(of R X) = X

structure CategoryTheory.CommAlgCat.Hom {R : Type u} [CommRing R] (A B : CommAlgCat R) : Type v

The type of morphisms in CommAlgCat R.

• hom' : ↑A →ₐ[R] ↑B

  The underlying algebra map.

theorem CategoryTheory.CommAlgCat.Hom.ext {R : Type u} {inst✝ : CommRing R} {A B : CommAlgCat R} {x y : A.Hom B} (hom' : x.hom' = y.hom') : x = y

theorem CategoryTheory.CommAlgCat.Hom.ext_iff {R : Type u} {inst✝ : CommRing R} {A B : CommAlgCat R} {x y : A.Hom B} : x = y ↔ x.hom' = y.hom'

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

Equations

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

instance CategoryTheory.CommAlgCat.instConcreteCategoryAlgHomCarrier {R : Type u} [CommRing R] : ConcreteCategory (CommAlgCat R) fun (x1 x2 : CommAlgCat R) => ↑x1 →ₐ[R] ↑x2

Equations

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

@[reducible, inline]

abbrev CategoryTheory.CommAlgCat.Hom.hom {R : Type u} [CommRing R] {A B : CommAlgCat R} (f : A.Hom B) : ↑A →ₐ[R] ↑B

Turn a morphism in CommAlgCat back into an AlgHom.

Equations

• f.hom = CategoryTheory.ConcreteCategory.hom f

@[reducible, inline]

abbrev CategoryTheory.CommAlgCat.ofHom {R : Type u} [CommRing R] {X Y : Type v} [CommRing X] [Algebra R X] [CommRing Y] [Algebra R Y] (f : X →ₐ[R] Y) : of R X ⟶ of R Y

Typecheck an AlgHom as a morphism in CommAlgCat.

Equations

• CategoryTheory.CommAlgCat.ofHom f = CategoryTheory.ConcreteCategory.ofHom f

def CategoryTheory.CommAlgCat.Hom.Simps.hom {R : Type u} [CommRing R] (A B : CommAlgCat R) (f : A.Hom B) : ↑A →ₐ[R] ↑B

Use the ConcreteCategory.hom projection for @[simps] lemmas.

Equations

• CategoryTheory.CommAlgCat.Hom.Simps.hom A B f = f.hom

The results below duplicate the ConcreteCategory simp lemmas, but we can keep them for dsimp.

@[simp]

theorem CategoryTheory.CommAlgCat.hom_id {R : Type u} [CommRing R] {A : CommAlgCat R} : Hom.hom (CategoryStruct.id A) = AlgHom.id R ↑A

theorem CategoryTheory.CommAlgCat.id_apply {R : Type u} [CommRing R] (A : CommAlgCat R) (a : ↑A) : (ConcreteCategory.hom (CategoryStruct.id A)) a = a

@[simp]

theorem CategoryTheory.CommAlgCat.hom_comp {R : Type u} [CommRing R] {A B C : CommAlgCat R} (f : A ⟶ B) (g : B ⟶ C) : Hom.hom (CategoryStruct.comp f g) = (Hom.hom g).comp (Hom.hom f)

theorem CategoryTheory.CommAlgCat.comp_apply {R : Type u} [CommRing R] {A B C : CommAlgCat R} (f : A ⟶ B) (g : B ⟶ C) (a : ↑A) : (ConcreteCategory.hom (CategoryStruct.comp f g)) a = (ConcreteCategory.hom g) ((ConcreteCategory.hom f) a)

theorem CategoryTheory.CommAlgCat.hom_ext {R : Type u} [CommRing R] {A B : CommAlgCat R} {f g : A ⟶ B} (hf : Hom.hom f = Hom.hom g) : f = g

theorem CategoryTheory.CommAlgCat.hom_ext_iff {R : Type u} [CommRing R] {A B : CommAlgCat R} {f g : A ⟶ B} : f = g ↔ Hom.hom f = Hom.hom g

@[simp]

theorem CategoryTheory.CommAlgCat.hom_ofHom {R : Type u} [CommRing R] {X Y : Type v} [CommRing X] [Algebra R X] [CommRing Y] [Algebra R Y] (f : X →ₐ[R] Y) : Hom.hom (ofHom f) = f

@[simp]

theorem CategoryTheory.CommAlgCat.ofHom_hom {R : Type u} [CommRing R] {A B : CommAlgCat R} (f : A ⟶ B) : ofHom (Hom.hom f) = f

@[simp]

theorem CategoryTheory.CommAlgCat.ofHom_id {R : Type u} [CommRing R] {X : Type v} [CommRing X] [Algebra R X] : ofHom (AlgHom.id R X) = CategoryStruct.id (of R X)

@[simp]

theorem CategoryTheory.CommAlgCat.ofHom_comp {R : Type u} [CommRing R] {X Y Z : Type v} [CommRing X] [Algebra R X] [CommRing Y] [Algebra R Y] [CommRing Z] [Algebra R Z] (f : X →ₐ[R] Y) (g : Y →ₐ[R] Z) : ofHom (g.comp f) = CategoryStruct.comp (ofHom f) (ofHom g)

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

theorem CategoryTheory.CommAlgCat.inv_hom_apply {R : Type u} [CommRing R] {A B : CommAlgCat R} (e : A ≅ B) (x : ↑A) : (ConcreteCategory.hom e.inv) ((ConcreteCategory.hom e.hom) x) = x

theorem CategoryTheory.CommAlgCat.hom_inv_apply {R : Type u} [CommRing R] {A B : CommAlgCat R} (e : A ≅ B) (x : ↑B) : (ConcreteCategory.hom e.hom) ((ConcreteCategory.hom e.inv) x) = x

instance CategoryTheory.CommAlgCat.instInhabited {R : Type u} [CommRing R] : Inhabited (CommAlgCat R)

Equations

• CategoryTheory.CommAlgCat.instInhabited = { default := CategoryTheory.CommAlgCat.of R R }

theorem CategoryTheory.CommAlgCat.forget_obj {R : Type u} [CommRing R] (A : CommAlgCat R) : (forget (CommAlgCat R)).obj A = ↑A

theorem CategoryTheory.CommAlgCat.forget_map {R : Type u} [CommRing R] {A B : CommAlgCat R} (f : A ⟶ B) : (forget (CommAlgCat R)).map f = ⇑(ConcreteCategory.hom f)

instance CategoryTheory.CommAlgCat.instCommRingObjForget {R : Type u} [CommRing R] {A : CommAlgCat R} : CommRing ((forget (CommAlgCat R)).obj A)

Equations

• CategoryTheory.CommAlgCat.instCommRingObjForget = inferInstanceAs (CommRing ↑A)

instance CategoryTheory.CommAlgCat.instAlgebraObjForget {R : Type u} [CommRing R] {A : CommAlgCat R} : Algebra R ((forget (CommAlgCat R)).obj A)

Equations

• CategoryTheory.CommAlgCat.instAlgebraObjForget = inferInstanceAs (Algebra R ↑A)

instance CategoryTheory.CommAlgCat.hasForgetToCommRingCat {R : Type u} [CommRing R] : HasForget₂ (CommAlgCat R) CommRingCat

Equations

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

instance CategoryTheory.CommAlgCat.hasForgetToAlgCat {R : Type u} [CommRing R] : HasForget₂ (CommAlgCat R) (AlgCat R)

Equations

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

@[simp]

theorem CategoryTheory.CommAlgCat.forget₂_commRingCat_obj {R : Type u} [CommRing R] (A : CommAlgCat R) : (forget₂ (CommAlgCat R) CommRingCat).obj A = CommRingCat.of ↑A

@[simp]

theorem CategoryTheory.CommAlgCat.forget₂_commRingCat_map {R : Type u} [CommRing R] {A B : CommAlgCat R} (f : A ⟶ B) : (forget₂ (CommAlgCat R) CommRingCat).map f = CommRingCat.ofHom ↑(Hom.hom f)

@[simp]

theorem CategoryTheory.CommAlgCat.forget₂_algCat_obj {R : Type u} [CommRing R] (A : CommAlgCat R) : (forget₂ (CommAlgCat R) (AlgCat R)).obj A = AlgCat.of R ↑A

@[simp]

theorem CategoryTheory.CommAlgCat.forget₂_algCat_map {R : Type u} [CommRing R] {A B : CommAlgCat R} (f : A ⟶ B) : (forget₂ (CommAlgCat R) (AlgCat R)).map f = AlgCat.ofHom (Hom.hom f)

def CategoryTheory.CommAlgCat.isoMk {R : Type u} [CommRing R] {X Y : Type v} {x✝ : CommRing X} {x✝¹ : CommRing Y} {x✝² : Algebra R X} {x✝³ : Algebra R Y} (e : X ≃ₐ[R] Y) : of R X ≅ of R Y

Build an isomorphism in the category CommAlgCat R from an AlgEquiv between commutative Algebras.

Equations

• CategoryTheory.CommAlgCat.isoMk e = { hom := CategoryTheory.CommAlgCat.ofHom ↑e, inv := CategoryTheory.CommAlgCat.ofHom ↑e.symm, hom_inv_id := ⋯, inv_hom_id := ⋯ }

@[simp]

theorem CategoryTheory.CommAlgCat.isoMk_inv {R : Type u} [CommRing R] {X Y : Type v} {x✝ : CommRing X} {x✝¹ : CommRing Y} {x✝² : Algebra R X} {x✝³ : Algebra R Y} (e : X ≃ₐ[R] Y) : (isoMk e).inv = ofHom ↑e.symm

@[simp]

theorem CategoryTheory.CommAlgCat.isoMk_hom {R : Type u} [CommRing R] {X Y : Type v} {x✝ : CommRing X} {x✝¹ : CommRing Y} {x✝² : Algebra R X} {x✝³ : Algebra R Y} (e : X ≃ₐ[R] Y) : (isoMk e).hom = ofHom ↑e

def CategoryTheory.CommAlgCat.ofIso {R : Type u} [CommRing R] {A B : CommAlgCat R} (i : A ≅ B) : ↑A ≃ₐ[R] ↑B

Build an AlgEquiv from an isomorphism in the category CommAlgCat R.

Equations

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

@[simp]

theorem CategoryTheory.CommAlgCat.ofIso_apply {R : Type u} [CommRing R] {A B : CommAlgCat R} (i : A ≅ B) (a : ↑A) : (ofIso i) a = (ConcreteCategory.hom i.hom) a

@[simp]

theorem CategoryTheory.CommAlgCat.ofIso_symm_apply {R : Type u} [CommRing R] {A B : CommAlgCat R} (i : A ≅ B) (a : ↑B) : (ofIso i).symm a = (ConcreteCategory.hom i.inv) a

def CategoryTheory.CommAlgCat.isoEquivAlgEquiv {R : Type u} [CommRing R] {X Y : Type v} [CommRing X] [Algebra R X] [CommRing Y] [Algebra R Y] : (of R X ≅ of R Y) ≃ X ≃ₐ[R] Y

Algebra equivalences between Algebras are the same as isomorphisms in CommAlgCat.

Equations

• CategoryTheory.CommAlgCat.isoEquivAlgEquiv = { toFun := CategoryTheory.CommAlgCat.ofIso, invFun := CategoryTheory.CommAlgCat.isoMk, left_inv := ⋯, right_inv := ⋯ }

@[simp]

theorem CategoryTheory.CommAlgCat.isoEquivAlgEquiv_apply {R : Type u} [CommRing R] {X Y : Type v} [CommRing X] [Algebra R X] [CommRing Y] [Algebra R Y] (i : of R X ≅ of R Y) : isoEquivAlgEquiv i = ofIso i

@[simp]

theorem CategoryTheory.CommAlgCat.isoEquivAlgEquiv_symm_apply {R : Type u} [CommRing R] {X Y : Type v} [CommRing X] [Algebra R X] [CommRing Y] [Algebra R Y] (e : X ≃ₐ[R] Y) : isoEquivAlgEquiv.symm e = isoMk e

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

def CategoryTheory.commAlgCatEquivUnder (R : CommRingCat) : CommAlgCat ↑R ≌ Under R

The category of commutative algebras over a commutative ring R is the same as commutative rings under R.

Equations

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

@[simp]

theorem CategoryTheory.commAlgCatEquivUnder_functor_obj (R : CommRingCat) (A : CommAlgCat ↑R) : (commAlgCatEquivUnder R).functor.obj A = R.mkUnder ↑A

@[simp]

theorem CategoryTheory.commAlgCatEquivUnder_counitIso (R : CommRingCat) : (commAlgCatEquivUnder R).counitIso = Iso.refl ({ obj := fun (A : Under R) => CommAlgCat.of ↑R ↑A.right, map := fun {A B : Under R} (f : A ⟶ B) => CommAlgCat.ofHom (CommRingCat.toAlgHom f), map_id := ⋯, map_comp := ⋯ }.comp { obj := fun (A : CommAlgCat ↑R) => R.mkUnder ↑A, map := fun {A B : CommAlgCat ↑R} (f : A ⟶ B) => (CommAlgCat.Hom.hom f).toUnder, map_id := ⋯, map_comp := ⋯ })

@[simp]

theorem CategoryTheory.commAlgCatEquivUnder_inverse_map (R : CommRingCat) {A B : Under R} (f : A ⟶ B) : (commAlgCatEquivUnder R).inverse.map f = CommAlgCat.ofHom (CommRingCat.toAlgHom f)

@[simp]

theorem CategoryTheory.commAlgCatEquivUnder_functor_map (R : CommRingCat) {A B : CommAlgCat ↑R} (f : A ⟶ B) : (commAlgCatEquivUnder R).functor.map f = (CommAlgCat.Hom.hom f).toUnder

@[simp]

theorem CategoryTheory.commAlgCatEquivUnder_inverse_obj_carrier (R : CommRingCat) (A : Under R) : ↑((commAlgCatEquivUnder R).inverse.obj A) = ↑A.right

@[simp]

theorem CategoryTheory.commAlgCatEquivUnder_unitIso (R : CommRingCat) : (commAlgCatEquivUnder R).unitIso = NatIso.ofComponents (fun (A : CommAlgCat ↑R) => CommAlgCat.isoMk (let __RingEquiv := RingEquiv.refl ↑A; { toEquiv := __RingEquiv.toEquiv, map_mul' := ⋯, map_add' := ⋯, commutes' := ⋯ })) ⋯