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

full_name: SemiRingCat
code: /-- The category of semirings. -/
abbrev SemiRingCat : Type (u + 1) 
goal: Type (u + 1)

full_name: SemiRingCatMax
code: /-- An alias for `Semiring.{max u v}`, to deal around unification issues. -/
@[nolint checkUnivs]
abbrev SemiRingCatMax.{u1, u2} 
goal: Type ((max u1 u2) + 1)

full_name: SemiRingCat.AssocRingHom
code: /-- `RingHom` doesn't actually assume associativity. This alias is needed to make the category
theory machinery work. We use the same trick in `MonCat.AssocMonoidHom`. -/
abbrev AssocRingHom (M N : Type*) [Semiring M] [Semiring N] 
goal: Type (max u_1 u_2)

full_name: SemiRingCat.bundledHom
code: instance bundledHom : BundledHom AssocRingHom 
goal: CategoryTheory.BundledHom SemiRingCat.AssocRingHom

full_name: SemiRingCat.forget_obj_eq_coe
code: unif_hint forget_obj_eq_coe (R : SemiRingCat) where ⊢
  (forget SemiRingCat).obj R ≟ R
goal: Prop

full_name: SemiRingCat.instSemiring
code: instance instSemiring (X : SemiRingCat) : Semiring X 
goal: Semiring ↑X

full_name: SemiRingCat.instFunLike
code: instance instFunLike {X Y : SemiRingCat} : FunLike (X ⟶ Y) X Y 
goal: FunLike (X ⟶ Y) ↑X ↑Y

full_name: SemiRingCat.instRingHomClass
code: instance instRingHomClass {X Y : SemiRingCat} : RingHomClass (X ⟶ Y) X Y 
goal: RingHomClass (X ⟶ Y) ↑X ↑Y

full_name: SemiRingCat.coe_id
code: lemma coe_id {X : SemiRingCat} : (𝟙 X : X → X) = id 
goal: ⇑(𝟙 X) = id

full_name: SemiRingCat.coe_comp
code: lemma coe_comp {X Y Z : SemiRingCat} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f

full_name: SemiRingCat.forget_map
code: @[simp] lemma forget_map {X Y : SemiRingCat} (f : X ⟶ Y) :
    (forget SemiRingCat).map f = (f : X → Y) 
goal: (CategoryTheory.forget SemiRingCat).map f = ⇑f

full_name: SemiRingCat.ext
code: lemma ext {X Y : SemiRingCat} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g 
goal: f = g

full_name: SemiRingCat.of
code: /-- Construct a bundled SemiRing from the underlying type and typeclass. -/
def of (R : Type u) [Semiring R] : SemiRingCat 
goal: SemiRingCat

full_name: SemiRingCat.coe_of
code: @[simp]
theorem coe_of (R : Type u) [Semiring R] : (SemiRingCat.of R : Type u) = R 
goal: ↑(SemiRingCat.of R) = R

full_name: SemiRingCat.coe_ringHom_id
code: @[simp] theorem coe_ringHom_id {X : SemiRingCat} :
    @DFunLike.coe (X →+* X) X (fun _ ↦ X) _ (𝟙 X) = id 
goal: ⇑(𝟙 X) = id

full_name: SemiRingCat.coe_id_of
code: @[simp] theorem coe_id_of {X : Type u} [Semiring X] :
    @DFunLike.coe no_index (SemiRingCat.of X ⟶ SemiRingCat.of X) X
      (fun _ ↦ X) _
      (𝟙 (of X)) =
    @DFunLike.coe (X →+* X) X (fun _ ↦ X) _ (RingHom.id X) 
goal: ⇑(𝟙 (SemiRingCat.of X)) = ⇑(RingHom.id X)

full_name: SemiRingCat.coe_comp_of
code: @[simp] theorem coe_comp_of {X Y Z : Type u} [Semiring X] [Semiring Y] [Semiring Z]
    (f : X →+* Y) (g : Y →+* Z) :
    @DFunLike.coe no_index (SemiRingCat.of X ⟶ SemiRingCat.of Z) X
      (fun _ ↦ Z) _
      (CategoryStruct.comp (X := SemiRingCat.of X) (Y := SemiRingCat.of Y) (Z := SemiRingCat.of Z)
        f g) =
    @DFunLike.coe (X →+* Z) X (fun _ ↦ Z) _ (RingHom.comp g f) 
goal: ⇑(f ≫ g) = ⇑(g.comp f)

full_name: SemiRingCat.ext_of
code: @[ext] theorem ext_of {X Y : Type u} [Semiring X] [Semiring Y] (f g : X →+* Y)
    (h : ∀ x, f x = g x) :
    @Eq (SemiRingCat.of X ⟶ SemiRingCat.of Y) f g 
goal: f = g

full_name: SemiRingCat.RingEquiv_coe_eq
code: @[simp]
lemma RingEquiv_coe_eq {X Y : Type _} [Semiring X] [Semiring Y] (e : X ≃+* Y) :
    (@DFunLike.coe (SemiRingCat.of X ⟶ SemiRingCat.of Y) _ (fun _ => (forget SemiRingCat).obj _)
      ConcreteCategory.instFunLike (e : X →+* Y) : X → Y) = ↑e 
goal: ⇑↑e = ⇑e

full_name: SemiRingCat.instInhabited
code: instance : Inhabited SemiRingCat 
goal: Inhabited SemiRingCat

full_name: SemiRingCat.hasForgetToMonCat
code: instance hasForgetToMonCat : HasForget₂ SemiRingCat MonCat 
goal: CategoryTheory.HasForget₂ SemiRingCat MonCat

full_name: SemiRingCat.hasForgetToAddCommMonCat
code: instance hasForgetToAddCommMonCat : HasForget₂ SemiRingCat AddCommMonCat 
goal: CategoryTheory.HasForget₂ SemiRingCat AddCommMonCat

full_name: SemiRingCat.ofHom
code: /-- Typecheck a `RingHom` as a morphism in `SemiRingCat`. -/
def ofHom {R S : Type u} [Semiring R] [Semiring S] (f : R →+* S) : of R ⟶ of S 
goal: SemiRingCat.of R ⟶ SemiRingCat.of S

full_name: SemiRingCat.ofHom_apply
code: @[simp, nolint simpNF]
theorem ofHom_apply {R S : Type u} [Semiring R] [Semiring S] (f : R →+* S) (x : R) :
    ofHom f x = f x 
goal: (SemiRingCat.ofHom f) x = f x

full_name: RingEquiv.toSemiRingCatIso
code: /--
Ring equivalence are isomorphisms in category of semirings
-/
@[simps]
def _root_.RingEquiv.toSemiRingCatIso {X Y : Type u} [Semiring X] [Semiring Y] (e : X ≃+* Y) :
    SemiRingCat.of X ≅ SemiRingCat.of Y 
goal: SemiRingCat.of X ≅ SemiRingCat.of Y

full_name: RingEquiv.toSemiRingCatIso_inv
code: /--
Ring equivalence are isomorphisms in category of semirings
-/
@[simps]
def _root_.RingEquiv.toSemiRingCatIso {X Y : Type u} [Semiring X] [Semiring Y] (e : X ≃+* Y) :
    SemiRingCat.of X ≅ SemiRingCat.of Y 
goal: e.toSemiRingCatIso.inv = e.symm.toRingHom

full_name: RingEquiv.toSemiRingCatIso_hom
code: /--
Ring equivalence are isomorphisms in category of semirings
-/
@[simps]
def _root_.RingEquiv.toSemiRingCatIso {X Y : Type u} [Semiring X] [Semiring Y] (e : X ≃+* Y) :
    SemiRingCat.of X ≅ SemiRingCat.of Y 
goal: e.toSemiRingCatIso.hom = e.toRingHom

full_name: SemiRingCat.forgetReflectIsos
code: instance forgetReflectIsos : (forget SemiRingCat).ReflectsIsomorphisms 
goal: (CategoryTheory.forget SemiRingCat).ReflectsIsomorphisms

full_name: RingCat
code: /-- The category of rings. -/
abbrev RingCat : Type (u + 1) 
goal: Type (u + 1)

full_name: RingCat.instParentProjectionSemiringRingToSemiring
code: instance : BundledHom.ParentProjection @Ring.toSemiring 
goal: CategoryTheory.BundledHom.ParentProjection @Ring.toSemiring

full_name: RingCat.instRingα
code: instance (X : RingCat) : Ring X 
goal: Ring ↑X

full_name: RingCat.forget_obj_eq_coe
code: unif_hint forget_obj_eq_coe (R : RingCat) where ⊢
  (forget RingCat).obj R ≟ R
goal: Prop

full_name: RingCat.instRing
code: instance instRing (X : RingCat) : Ring X 
goal: Ring ↑X

full_name: RingCat.instFunLike
code: instance instFunLike {X Y : RingCat} : FunLike (X ⟶ Y) X Y 
goal: FunLike (X ⟶ Y) ↑X ↑Y

full_name: RingCat.instRingHomClass
code: instance instRingHomClass {X Y : RingCat} : RingHomClass (X ⟶ Y) X Y 
goal: RingHomClass (X ⟶ Y) ↑X ↑Y

full_name: RingCat.coe_id
code: lemma coe_id {X : RingCat} : (𝟙 X : X → X) = id 
goal: ⇑(𝟙 X) = id

full_name: RingCat.coe_comp
code: lemma coe_comp {X Y Z : RingCat} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f

full_name: RingCat.forget_map
code: @[simp] lemma forget_map {X Y : RingCat} (f : X ⟶ Y) : (forget RingCat).map f = (f : X → Y) 
goal: (CategoryTheory.forget RingCat).map f = ⇑f

full_name: RingCat.ext
code: lemma ext {X Y : RingCat} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g 
goal: f = g

full_name: RingCat.of
code: /-- Construct a bundled `RingCat` from the underlying type and typeclass. -/
def of (R : Type u) [Ring R] : RingCat 
goal: RingCat

full_name: RingCat.ofHom
code: /-- Typecheck a `RingHom` as a morphism in `RingCat`. -/
def ofHom {R S : Type u} [Ring R] [Ring S] (f : R →+* S) : of R ⟶ of S 
goal: RingCat.of R ⟶ RingCat.of S

full_name: RingCat.instInhabited
code: instance : Inhabited RingCat 
goal: Inhabited RingCat

full_name: RingCat.instRingα_1
code: instance (R : RingCat) : Ring R 
goal: Ring ↑R

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

full_name: RingCat.coe_ringHom_id
code: @[simp] theorem coe_ringHom_id {X : RingCat} :
    @DFunLike.coe (X →+* X) X (fun _ ↦ X) _ (𝟙 X) = id 
goal: ⇑(𝟙 X) = id

full_name: RingCat.coe_id_of
code: @[simp] theorem coe_id_of {X : Type u} [Ring X] :
    @DFunLike.coe no_index (RingCat.of X ⟶ RingCat.of X) X
      (fun _ ↦ X) _
      (𝟙 (of X)) =
    @DFunLike.coe (X →+* X) X (fun _ ↦ X) _ (RingHom.id X) 
goal: ⇑(𝟙 (RingCat.of X)) = ⇑(RingHom.id X)

full_name: RingCat.coe_comp_of
code: @[simp] theorem coe_comp_of {X Y Z : Type u} [Ring X] [Ring Y] [Ring Z]
    (f : X →+* Y) (g : Y →+* Z) :
    @DFunLike.coe no_index (RingCat.of X ⟶ RingCat.of Z) X
      (fun _ ↦ Z) _
      (CategoryStruct.comp (X := RingCat.of X) (Y := RingCat.of Y) (Z := RingCat.of Z)
        f g) =
    @DFunLike.coe (X →+* Z) X (fun _ ↦ Z) _ (RingHom.comp g f) 
goal: ⇑(f ≫ g) = ⇑(g.comp f)

full_name: RingCat.ext_of
code: @[ext] theorem ext_of {X Y : Type u} [Ring X] [Ring Y] (f g : X →+* Y)
    (h : ∀ x, f x = g x) :
    @Eq (RingCat.of X ⟶ RingCat.of Y) f g 
goal: f = g

full_name: RingCat.RingEquiv_coe_eq
code: @[simp]
lemma RingEquiv_coe_eq {X Y : Type _} [Ring X] [Ring Y] (e : X ≃+* Y) :
    (@DFunLike.coe (RingCat.of X ⟶ RingCat.of Y) _ (fun _ => (forget RingCat).obj _)
      ConcreteCategory.instFunLike (e : X →+* Y) : X → Y) = ↑e 
goal: ⇑↑e = ⇑e

full_name: RingCat.hasForgetToSemiRingCat
code: instance hasForgetToSemiRingCat : HasForget₂ RingCat SemiRingCat 
goal: CategoryTheory.HasForget₂ RingCat SemiRingCat

full_name: RingCat.hasForgetToAddCommGrp
code: instance hasForgetToAddCommGrp : HasForget₂ RingCat AddCommGrp 
goal: CategoryTheory.HasForget₂ RingCat AddCommGrp

full_name: CommSemiRingCat
code: /-- The category of commutative semirings. -/
def CommSemiRingCat : Type (u + 1) 
goal: Type (u + 1)

full_name: CommSemiRingCat.instParentProjectionSemiringCommSemiringToSemiring
code: instance : BundledHom.ParentProjection @CommSemiring.toSemiring 
goal: CategoryTheory.BundledHom.ParentProjection @CommSemiring.toSemiring

full_name: CommSemiRingCat.instConcreteCategory
code: instance : ConcreteCategory CommSemiRingCat 
goal: CategoryTheory.ConcreteCategory CommSemiRingCat

full_name: CommSemiRingCat.instCoeSortType
code: instance : CoeSort CommSemiRingCat Type* 
goal: CoeSort CommSemiRingCat (Type u_1)

full_name: CommSemiRingCat.instCommSemiringα
code: instance (X : CommSemiRingCat) : CommSemiring X 
goal: CommSemiring ↑X

full_name: CommSemiRingCat.forget_obj_eq_coe
code: unif_hint forget_obj_eq_coe (R : CommSemiRingCat) where ⊢
  (forget CommSemiRingCat).obj R ≟ R
goal: Prop

full_name: CommSemiRingCat.instCommSemiring
code: instance instCommSemiring (X : CommSemiRingCat) : CommSemiring X 
goal: CommSemiring ↑X

full_name: CommSemiRingCat.instCommSemiring'
code: instance instCommSemiring' (X : CommSemiRingCat) : CommSemiring <| (forget CommSemiRingCat).obj X 
goal: CommSemiring ((CategoryTheory.forget CommSemiRingCat).obj X)

full_name: CommSemiRingCat.instFunLike
code: instance instFunLike {X Y : CommSemiRingCat} : FunLike (X ⟶ Y) X Y 
goal: FunLike (X ⟶ Y) ↑X ↑Y

full_name: CommSemiRingCat.instRingHomClass
code: instance instRingHomClass {X Y : CommSemiRingCat} : RingHomClass (X ⟶ Y) X Y 
goal: RingHomClass (X ⟶ Y) ↑X ↑Y

full_name: CommSemiRingCat.coe_id
code: lemma coe_id {X : CommSemiRingCat} : (𝟙 X : X → X) = id 
goal: ⇑(𝟙 X) = id

full_name: CommSemiRingCat.coe_comp
code: lemma coe_comp {X Y Z : CommSemiRingCat} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f

full_name: CommSemiRingCat.forget_map
code: @[simp] lemma forget_map {X Y : CommSemiRingCat} (f : X ⟶ Y) :
  (forget CommSemiRingCat).map f = (f : X → Y) 
goal: (CategoryTheory.forget CommSemiRingCat).map f = ⇑f

full_name: CommSemiRingCat.ext
code: lemma ext {X Y : CommSemiRingCat} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g 
goal: f = g

full_name: CommSemiRingCat.of
code: /-- Construct a bundled `CommSemiRingCat` from the underlying type and typeclass. -/
def of (R : Type u) [CommSemiring R] : CommSemiRingCat 
goal: CommSemiRingCat

full_name: CommSemiRingCat.ofHom
code: /-- Typecheck a `RingHom` as a morphism in `CommSemiRingCat`. -/
def ofHom {R S : Type u} [CommSemiring R] [CommSemiring S] (f : R →+* S) : of R ⟶ of S 
goal: CommSemiRingCat.of R ⟶ CommSemiRingCat.of S

full_name: CommSemiRingCat.RingEquiv_coe_eq
code: @[simp]
lemma RingEquiv_coe_eq {X Y : Type _} [CommSemiring X] [CommSemiring Y] (e : X ≃+* Y) :
    (@DFunLike.coe (CommSemiRingCat.of X ⟶ CommSemiRingCat.of Y) _
      (fun _ => (forget CommSemiRingCat).obj _)
      ConcreteCategory.instFunLike (e : X →+* Y) : X → Y) = ↑e 
goal: ⇑↑e = ⇑e

full_name: CommSemiRingCat.instInhabited
code: instance : Inhabited CommSemiRingCat 
goal: Inhabited CommSemiRingCat

full_name: CommSemiRingCat.instCommSemiringα_1
code: instance (R : CommSemiRingCat) : CommSemiring R 
goal: CommSemiring ↑R

full_name: CommSemiRingCat.coe_of
code: @[simp]
theorem coe_of (R : Type u) [CommSemiring R] : (CommSemiRingCat.of R : Type u) = R 
goal: ↑(CommSemiRingCat.of R) = R

full_name: CommSemiRingCat.coe_ringHom_id
code: @[simp] theorem coe_ringHom_id {X : CommSemiRingCat} :
    @DFunLike.coe (X →+* X) X (fun _ ↦ X) _ (𝟙 X) = id 
goal: ⇑(𝟙 X) = id

full_name: CommSemiRingCat.coe_id_of
code: @[simp] theorem coe_id_of {X : Type u} [CommSemiring X] :
    @DFunLike.coe no_index (CommSemiRingCat.of X ⟶ CommSemiRingCat.of X) X
      (fun _ ↦ X) _
      (𝟙 (of X)) =
    @DFunLike.coe (X →+* X) X (fun _ ↦ X) _ (RingHom.id X) 
goal: ⇑(𝟙 (CommSemiRingCat.of X)) = ⇑(RingHom.id X)

full_name: CommSemiRingCat.coe_comp_of
code: @[simp] theorem coe_comp_of {X Y Z : Type u} [CommSemiring X] [CommSemiring Y] [CommSemiring Z]
    (f : X →+* Y) (g : Y →+* Z) :
    @DFunLike.coe no_index (CommSemiRingCat.of X ⟶ CommSemiRingCat.of Z) X
      (fun _ ↦ Z) _
      (CategoryStruct.comp (X := CommSemiRingCat.of X) (Y := CommSemiRingCat.of Y)
        (Z := CommSemiRingCat.of Z) f g) =
    @DFunLike.coe (X →+* Z) X (fun _ ↦ Z) _ (RingHom.comp g f) 
goal: ⇑(f ≫ g) = ⇑(g.comp f)

full_name: CommSemiRingCat.ext_of
code: @[ext] theorem ext_of {X Y : Type u} [CommSemiring X] [CommSemiring Y] (f g : X →+* Y)
    (h : ∀ x, f x = g x) :
    @Eq (CommSemiRingCat.of X ⟶ CommSemiRingCat.of Y) f g 
goal: f = g

full_name: CommSemiRingCat.hasForgetToSemiRingCat
code: instance hasForgetToSemiRingCat : HasForget₂ CommSemiRingCat SemiRingCat 
goal: CategoryTheory.HasForget₂ CommSemiRingCat SemiRingCat

full_name: CommSemiRingCat.hasForgetToCommMonCat
code: /-- The forgetful functor from commutative rings to (multiplicative) commutative monoids. -/
instance hasForgetToCommMonCat : HasForget₂ CommSemiRingCat CommMonCat 
goal: CategoryTheory.HasForget₂ CommSemiRingCat CommMonCat

full_name: RingEquiv.toCommSemiRingCatIso_hom
code: /--
Ring equivalence are isomorphisms in category of commutative semirings
-/
@[simps]
def _root_.RingEquiv.toCommSemiRingCatIso {X Y : Type u} [CommSemiring X] [CommSemiring Y]
    (e : X ≃+* Y) : CommSemiRingCat.of X ≅ CommSemiRingCat.of Y 
goal: e.toCommSemiRingCatIso.hom = e.toRingHom

full_name: RingEquiv.toCommSemiRingCatIso_inv
code: /--
Ring equivalence are isomorphisms in category of commutative semirings
-/
@[simps]
def _root_.RingEquiv.toCommSemiRingCatIso {X Y : Type u} [CommSemiring X] [CommSemiring Y]
    (e : X ≃+* Y) : CommSemiRingCat.of X ≅ CommSemiRingCat.of Y 
goal: e.toCommSemiRingCatIso.inv = e.symm.toRingHom

full_name: RingEquiv.toCommSemiRingCatIso
code: /--
Ring equivalence are isomorphisms in category of commutative semirings
-/
@[simps]
def _root_.RingEquiv.toCommSemiRingCatIso {X Y : Type u} [CommSemiring X] [CommSemiring Y]
    (e : X ≃+* Y) : CommSemiRingCat.of X ≅ CommSemiRingCat.of Y 
goal: CommSemiRingCat.of X ≅ CommSemiRingCat.of Y

full_name: CommSemiRingCat.forgetReflectIsos
code: instance forgetReflectIsos : (forget CommSemiRingCat).ReflectsIsomorphisms 
goal: (CategoryTheory.forget CommSemiRingCat).ReflectsIsomorphisms

full_name: CommRingCat
code: /-- The category of commutative rings. -/
def CommRingCat : Type (u + 1) 
goal: Type (u + 1)

full_name: CommRingCat.instParentProjectionRingCommRingToRing
code: instance : BundledHom.ParentProjection @CommRing.toRing 
goal: CategoryTheory.BundledHom.ParentProjection @CommRing.toRing

full_name: CommRingCat.instConcreteCategory
code: instance : ConcreteCategory CommRingCat 
goal: CategoryTheory.ConcreteCategory CommRingCat

full_name: CommRingCat.instCoeSortType
code: instance : CoeSort CommRingCat Type* 
goal: CoeSort CommRingCat (Type u_1)

full_name: CommRingCat.forget_obj_eq_coe
code: unif_hint forget_obj_eq_coe (R : CommRingCat) where ⊢
  (forget CommRingCat).obj R ≟ R
goal: Prop

full_name: CommRingCat.instCommRing
code: instance instCommRing (X : CommRingCat) : CommRing X 
goal: CommRing ↑X

full_name: CommRingCat.instCommRing'
code: instance instCommRing' (X : CommRingCat) : CommRing <| (forget CommRingCat).obj X 
goal: CommRing ((CategoryTheory.forget CommRingCat).obj X)

full_name: CommRingCat.instFunLike
code: instance instFunLike {X Y : CommRingCat} : FunLike (X ⟶ Y) X Y 
goal: FunLike (X ⟶ Y) ↑X ↑Y

full_name: CommRingCat.instRingHomClass
code: instance instRingHomClass {X Y : CommRingCat} : RingHomClass (X ⟶ Y) X Y 
goal: RingHomClass (X ⟶ Y) ↑X ↑Y

full_name: CommRingCat.coe_id
code: lemma coe_id {X : CommRingCat} : (𝟙 X : X → X) = id 
goal: ⇑(𝟙 X) = id

full_name: CommRingCat.coe_comp
code: lemma coe_comp {X Y Z : CommRingCat} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f

full_name: CommRingCat.id_apply
code: /-- Specialization of `ConcreteCategory.id_apply` because `simp` can't see through the defeq. -/
@[simp] lemma id_apply (R : CommRingCat) (x : R) : 𝟙 R x = x 
goal: (𝟙 R) x = x

full_name: CommRingCat.comp_apply
code: @[simp]
theorem comp_apply {R S T : CommRingCat} (f : R ⟶ S) (g : S ⟶ T) (x : R) :
    (f ≫ g) x = g (f x) 
goal: (f ≫ g) x = g (f x)

full_name: CommRingCat.forget_obj
code: @[simp] theorem forget_obj (R : CommRingCat) : (forget _).obj R = R 
goal: (CategoryTheory.forget CommRingCat).obj R = ↑R

full_name: CommRingCat.forget_map
code: @[simp] lemma forget_map {X Y : CommRingCat} (f : X ⟶ Y) :
    (forget CommRingCat).map f = (f : X → Y) 
goal: (CategoryTheory.forget CommRingCat).map f = ⇑f

full_name: CommRingCat.ext
code: lemma ext {X Y : CommRingCat} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g 
goal: f = g

full_name: CommRingCat.of
code: /-- Construct a bundled `CommRingCat` from the underlying type and typeclass. -/
def of (R : Type u) [CommRing R] : CommRingCat 
goal: CommRingCat

full_name: CommRingCat.instFunLike'
code: instance instFunLike' {X : Type*} [CommRing X] {Y : CommRingCat} :
    FunLike (CommRingCat.of X ⟶ Y) X Y 
goal: FunLike (CommRingCat.of X ⟶ Y) X ↑Y

full_name: CommRingCat.instFunLike''
code: instance instFunLike'' {X : CommRingCat} {Y : Type*} [CommRing Y] :
    FunLike (X ⟶ CommRingCat.of Y) X Y 
goal: FunLike (X ⟶ CommRingCat.of Y) (↑X) Y

full_name: CommRingCat.instFunLike'''
code: instance instFunLike''' {X Y : Type _} [CommRing X] [CommRing Y] :
    FunLike (CommRingCat.of X ⟶ CommRingCat.of Y) X Y 
goal: FunLike (CommRingCat.of X ⟶ CommRingCat.of Y) X Y

full_name: CommRingCat.ofHom
code: /-- Typecheck a `RingHom` as a morphism in `CommRingCat`. -/
def ofHom {R S : Type u} [CommRing R] [CommRing S] (f : R →+* S) : of R ⟶ of S 
goal: CommRingCat.of R ⟶ CommRingCat.of S

full_name: CommRingCat.RingEquiv_coe_eq
code: @[simp]
lemma RingEquiv_coe_eq {X Y : Type _} [CommRing X] [CommRing Y] (e : X ≃+* Y) :
    (@DFunLike.coe (CommRingCat.of X ⟶ CommRingCat.of Y) X (fun _ => Y)
      ConcreteCategory.instFunLike (e : X →+* Y) : X → Y) = ↑e 
goal: ⇑↑e = ⇑e

full_name: CommRingCat.instInhabited
code: instance : Inhabited CommRingCat 
goal: Inhabited CommRingCat

full_name: CommRingCat.instCommRingα
code: instance (R : CommRingCat) : CommRing R 
goal: CommRing ↑R

full_name: CommRingCat.coe_of
code: @[simp]
theorem coe_of (R : Type u) [CommRing R] : (CommRingCat.of R : Type u) = R 
goal: ↑(CommRingCat.of R) = R

full_name: CommRingCat.coe_ringHom_id
code: @[simp] theorem coe_ringHom_id {X : CommRingCat} :
    @DFunLike.coe (X →+* X) X (fun _ ↦ X) _ (𝟙 X) = id 
goal: ⇑(𝟙 X) = id

full_name: CommRingCat.coe_id_of
code: @[simp] theorem coe_id_of {X : Type u} [CommRing X] :
    @DFunLike.coe no_index (CommRingCat.of X ⟶ CommRingCat.of X) X
      (fun _ ↦ X) _
      (𝟙 (of X)) =
    @DFunLike.coe (X →+* X) X (fun _ ↦ X) _ (RingHom.id X) 
goal: ⇑(𝟙 (CommRingCat.of X)) = ⇑(RingHom.id X)

full_name: CommRingCat.coe_comp_of
code: @[simp] theorem coe_comp_of {X Y Z : Type u} [CommRing X] [CommRing Y] [CommRing Z]
    (f : X →+* Y) (g : Y →+* Z) :
    @DFunLike.coe no_index (CommRingCat.of X ⟶ CommRingCat.of Z) X
      (fun _ ↦ Z) _
      (CategoryStruct.comp (X := CommRingCat.of X) (Y := CommRingCat.of Y) (Z := CommRingCat.of Z)
        f g) =
    @DFunLike.coe (X →+* Z) X (fun _ ↦ Z) _ (RingHom.comp g f) 
goal: ⇑(f ≫ g) = ⇑(g.comp f)

full_name: CommRingCat.ext_of
code: @[ext] theorem ext_of {X Y : Type u} [CommRing X] [CommRing Y] (f g : X →+* Y)
    (h : ∀ x, f x = g x) :
    @Eq (CommRingCat.of X ⟶ CommRingCat.of Y) f g 
goal: f = g

full_name: CommRingCat.hasForgetToRingCat
code: instance hasForgetToRingCat : HasForget₂ CommRingCat RingCat 
goal: CategoryTheory.HasForget₂ CommRingCat RingCat

full_name: CommRingCat.hasForgetToCommSemiRingCat
code: /-- The forgetful functor from commutative rings to (multiplicative) commutative monoids. -/
instance hasForgetToCommSemiRingCat : HasForget₂ CommRingCat CommSemiRingCat 
goal: CategoryTheory.HasForget₂ CommRingCat CommSemiRingCat

full_name: CommRingCat.instFullCommSemiRingCatForget₂
code: instance : (forget₂ CommRingCat CommSemiRingCat).Full 
goal: (CategoryTheory.forget₂ CommRingCat CommSemiRingCat).Full

full_name: RingEquiv.toRingCatIso
code: /-- Build an isomorphism in the category `RingCat` from a `RingEquiv` between `RingCat`s. -/
@[simps]
def toRingCatIso [Ring X] [Ring Y] (e : X ≃+* Y) : RingCat.of X ≅ RingCat.of Y 
goal: RingCat.of X ≅ RingCat.of Y

full_name: RingEquiv.toRingCatIso_inv
code: /-- Build an isomorphism in the category `RingCat` from a `RingEquiv` between `RingCat`s. -/
@[simps]
def toRingCatIso [Ring X] [Ring Y] (e : X ≃+* Y) : RingCat.of X ≅ RingCat.of Y 
goal: e.toRingCatIso.inv = e.symm.toRingHom

full_name: RingEquiv.toRingCatIso_hom
code: /-- Build an isomorphism in the category `RingCat` from a `RingEquiv` between `RingCat`s. -/
@[simps]
def toRingCatIso [Ring X] [Ring Y] (e : X ≃+* Y) : RingCat.of X ≅ RingCat.of Y 
goal: e.toRingCatIso.hom = e.toRingHom

full_name: RingEquiv.toCommRingCatIso_hom
code: /-- Build an isomorphism in the category `CommRingCat` from a `RingEquiv` between `CommRingCat`s. -/
@[simps]
def toCommRingCatIso [CommRing X] [CommRing Y] (e : X ≃+* Y) :
    CommRingCat.of X ≅ CommRingCat.of Y 
goal: e.toCommRingCatIso.hom = e.toRingHom

full_name: RingEquiv.toCommRingCatIso_inv
code: /-- Build an isomorphism in the category `CommRingCat` from a `RingEquiv` between `CommRingCat`s. -/
@[simps]
def toCommRingCatIso [CommRing X] [CommRing Y] (e : X ≃+* Y) :
    CommRingCat.of X ≅ CommRingCat.of Y 
goal: e.toCommRingCatIso.inv = e.symm.toRingHom

full_name: RingEquiv.toCommRingCatIso
code: /-- Build an isomorphism in the category `CommRingCat` from a `RingEquiv` between `CommRingCat`s. -/
@[simps]
def toCommRingCatIso [CommRing X] [CommRing Y] (e : X ≃+* Y) :
    CommRingCat.of X ≅ CommRingCat.of Y 
goal: CommRingCat.of X ≅ CommRingCat.of Y

full_name: CategoryTheory.Iso.ringCatIsoToRingEquiv
code: /-- Build a `RingEquiv` from an isomorphism in the category `RingCat`. -/
def ringCatIsoToRingEquiv {X Y : RingCat} (i : X ≅ Y) : X ≃+* Y 
goal: ↑X ≃+* ↑Y

full_name: CategoryTheory.Iso.commRingCatIsoToRingEquiv
code: /-- Build a `RingEquiv` from an isomorphism in the category `CommRingCat`. -/
def commRingCatIsoToRingEquiv {X Y : CommRingCat} (i : X ≅ Y) : X ≃+* Y 
goal: ↑X ≃+* ↑Y

full_name: CategoryTheory.Iso.commRingIsoToRingEquiv_toRingHom
code: @[simp (high)]
theorem commRingIsoToRingEquiv_toRingHom {X Y : CommRingCat} (i : X ≅ Y) :
    i.commRingCatIsoToRingEquiv.toRingHom = i.hom 
goal: i.commRingCatIsoToRingEquiv.toRingHom = i.hom

full_name: CategoryTheory.Iso.commRingIsoToRingEquiv_symm_toRingHom
code: @[simp (high)]
theorem commRingIsoToRingEquiv_symm_toRingHom {X Y : CommRingCat} (i : X ≅ Y) :
    i.commRingCatIsoToRingEquiv.symm.toRingHom = i.inv 
goal: i.commRingCatIsoToRingEquiv.symm.toRingHom = i.inv

full_name: ringEquivIsoRingIso
code: /-- Ring equivalences between `RingCat`s are the same as (isomorphic to) isomorphisms in
`RingCat`. -/
def ringEquivIsoRingIso {X Y : Type u} [Ring X] [Ring Y] :
    X ≃+* Y ≅ RingCat.of X ≅ RingCat.of Y 
goal: X ≃+* Y ≅ RingCat.of X ≅ RingCat.of Y

full_name: ringEquivIsoCommRingIso
code: /-- Ring equivalences between `CommRingCat`s are the same as (isomorphic to) isomorphisms
in `CommRingCat`. -/
def ringEquivIsoCommRingIso {X Y : Type u} [CommRing X] [CommRing Y] :
    X ≃+* Y ≅ CommRingCat.of X ≅ CommRingCat.of Y 
goal: X ≃+* Y ≅ CommRingCat.of X ≅ CommRingCat.of Y

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

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

full_name: CommRingCat.comp_eq_ring_hom_comp
code: theorem CommRingCat.comp_eq_ring_hom_comp {R S T : CommRingCat} (f : R ⟶ S) (g : S ⟶ T) :
    f ≫ g = g.comp f 
goal: f ≫ g = RingHom.comp g f

full_name: CommRingCat.ringHom_comp_eq_comp
code: theorem CommRingCat.ringHom_comp_eq_comp {R S T : Type _} [CommRing R] [CommRing S] [CommRing T]
    (f : R →+* S) (g : S →+* T) : g.comp f = CommRingCat.ofHom f ≫ CommRingCat.ofHom g 
goal: g.comp f = CommRingCat.ofHom f ≫ CommRingCat.ofHom g

full_name: RingHom.comp_id_semiringCat
code: @[simp] theorem RingHom.comp_id_semiringCat
    {G : SemiRingCat.{u}} {H : Type u} [Semiring H] (f : G →+* H) : f.comp (𝟙 G) = f 
goal: f.comp (𝟙 G) = f

full_name: RingHom.id_semiringCat_comp
code: @[simp] theorem RingHom.id_semiringCat_comp
    {G : Type u} [Semiring G] {H : SemiRingCat.{u}} (f : G →+* H) : RingHom.comp (𝟙 H) f = f 
goal: RingHom.comp (𝟙 H) f = f

full_name: RingHom.comp_id_commSemiringCat
code: @[simp] theorem RingHom.comp_id_commSemiringCat
    {G : CommSemiRingCat.{u}} {H : Type u} [CommSemiring H] (f : G →+* H) : f.comp (𝟙 G) = f 
goal: f.comp (𝟙 G) = f

full_name: RingHom.id_commSemiringCat_comp
code: @[simp] theorem RingHom.id_commSemiringCat_comp
    {G : Type u} [CommSemiring G] {H : CommSemiRingCat.{u}} (f : G →+* H) :
    RingHom.comp (𝟙 H) f = f 
goal: RingHom.comp (𝟙 H) f = f

full_name: RingHom.comp_id_ringCat
code: @[simp] theorem RingHom.comp_id_ringCat
    {G : RingCat.{u}} {H : Type u} [Ring H] (f : G →+* H) : f.comp (𝟙 G) = f 
goal: f.comp (𝟙 G) = f

full_name: RingHom.id_ringCat_comp
code: @[simp] theorem RingHom.id_ringCat_comp
    {G : Type u} [Ring G] {H : RingCat.{u}} (f : G →+* H) : RingHom.comp (𝟙 H) f = f 
goal: RingHom.comp (𝟙 H) f = f

full_name: RingHom.comp_id_commRingCat
code: @[simp] theorem RingHom.comp_id_commRingCat
    {G : CommRingCat.{u}} {H : Type u} [CommRing H] (f : G →+* H) : f.comp (𝟙 G) = f 
goal: f.comp (𝟙 G) = f

full_name: RingHom.id_commRingCat_comp
code: @[simp] theorem RingHom.id_commRingCat_comp
    {G : Type u} [CommRing G] {H : CommRingCat.{u}} (f : G →+* H) : RingHom.comp (𝟙 H) f = f 
goal: RingHom.comp (𝟙 H) f = f