ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- PresheafOfModules.colimitCocone_pt
@[simps]
noncomputable def colimitCocone : Cocone F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {J : Type u₂} [CategoryTheory.Category.{v₂, u₂} J] (F : J ⥤ PresheafOfModules R) [{X Y : Cᵒᵖ} →
    (f : X ⟶ Y) →
      CategoryTheory.Limits.PreservesColimit (F ⋙ PresheafOfModules.evaluation R Y)
        (ModuleCat.restrictScalars (R.map f))] [∀ (X : Cᵒᵖ), CategoryTheory.Limits.HasColimit (F ⋙ PresheafOfModules.evaluation R X)]
Goal: (PresheafOfModules.colimitCocone F).pt = (PresheafOfModules.colimitBundledCore F).toPresheafOfModules
-- PresheafOfModules.colimitCocone_ι_app
@[simps]
noncomputable def colimitCocone : Cocone F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {J : Type u₂} [CategoryTheory.Category.{v₂, u₂} J] (F : J ⥤ PresheafOfModules R) [{X Y : Cᵒᵖ} →
    (f : X ⟶ Y) →
      CategoryTheory.Limits.PreservesColimit (F ⋙ PresheafOfModules.evaluation R Y)
        (ModuleCat.restrictScalars (R.map f))] [∀ (X : Cᵒᵖ), CategoryTheory.Limits.HasColimit (F ⋙ PresheafOfModules.evaluation R X)] (j : J)
Goal: (PresheafOfModules.colimitCocone F).ι.app j = PresheafOfModules.colimitCoconeιApp F j
-- ModuleCat.FilteredColimits.M.mk_eq
theorem M.mk_eq (x y : Σ j, F.obj j)
    (h : ∃ (k : J) (f : x.1 ⟶ k) (g : y.1 ⟶ k), F.map f x.2 = F.map g y.2) : M.mk F x = M.mk F y 
Arguments: {R : Type u} [Ring R] {J : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.IsFiltered J] (F : J ⥤ ModuleCatMax R) (x y : (j : J) × ↑(F.obj j)) (h : ∃ k f g, (F.map f) x.snd = (F.map g) y.snd)
Goal: ModuleCat.FilteredColimits.M.mk F x = ModuleCat.FilteredColimits.M.mk F y
-- ModuleCat.FilteredColimits.colimitSMulAux_eq_of_rel
theorem colimitSMulAux_eq_of_rel (r : R) (x y : Σ j, F.obj j)
    (h : Types.FilteredColimit.Rel (F ⋙ forget (ModuleCat R)) x y) :
    colimitSMulAux F r x = colimitSMulAux F r y 
Arguments: {R : Type u} [Ring R] {J : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.IsFiltered J] (F : J ⥤ ModuleCatMax R) (r : R) (x y : (j : J) × ↑(F.obj j)) (h : CategoryTheory.Limits.Types.FilteredColimit.Rel (F ⋙ CategoryTheory.forget (ModuleCat R)) x y)
Goal: ModuleCat.FilteredColimits.colimitSMulAux F r x = ModuleCat.FilteredColimits.colimitSMulAux F r y
-- ModuleCat.FilteredColimits.colimit_smul_mk_eq
@[simp]
theorem colimit_smul_mk_eq (r : R) (x : Σ j, F.obj j) : r • M.mk F x = M.mk F ⟨x.1, r • x.2⟩ 
Arguments: {R : Type u} [Ring R] {J : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.IsFiltered J] (F : J ⥤ ModuleCatMax R) (r : R) (x : (j : J) × ↑(F.obj j))
Goal: r • ModuleCat.FilteredColimits.M.mk F x = ModuleCat.FilteredColimits.M.mk F ⟨x.fst, r • x.snd⟩
-- _private.Mathlib.Algebra.Category.ModuleCat.FilteredColimits.0.ModuleCat.FilteredColimits.colimitModule.one_smul
private theorem colimitModule.one_smul (x : (M F)) : (1 : R) • x = x 
Arguments: {R : Type u} [Ring R] {J : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.IsFiltered J] (F : J ⥤ ModuleCatMax R) (x : ↑(ModuleCat.FilteredColimits.M F))
Goal: 1 • x = x
-- _private.Mathlib.Algebra.Category.ModuleCat.FilteredColimits.0.ModuleCat.FilteredColimits.colimitModule.add_smul
private theorem colimitModule.add_smul (r s : R) (x : (M F)) : (r + s) • x = r • x + s • x 
Arguments: {R : Type u} [Ring R] {J : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.IsFiltered J] (F : J ⥤ ModuleCatMax R) (r s : R) (x : ↑(ModuleCat.FilteredColimits.M F))
Goal: (r + s) • x = r • x + s • x
-- MonoidHom.precompEquiv_apply
@[simps]
def precompEquiv {α β : Type*} [Monoid α] [Monoid β] (e : α ≃* β) (γ : Type*) [Monoid γ] :
    (β →* γ) ≃ (α →* γ) 
Arguments: {α : Type u_1} {β : Type u_2} [Monoid α] [Monoid β] (e : α ≃* β) (γ : Type u_3) [Monoid γ] (f : β →* γ)
Goal: (MonoidHom.precompEquiv e γ) f = f.comp ↑e
-- MonoidHom.precompEquiv_symm_apply
@[simps]
def precompEquiv {α β : Type*} [Monoid α] [Monoid β] (e : α ≃* β) (γ : Type*) [Monoid γ] :
    (β →* γ) ≃ (α →* γ) 
Arguments: {α : Type u_1} {β : Type u_2} [Monoid α] [Monoid β] (e : α ≃* β) (γ : Type u_3) [Monoid γ] (g : α →* γ)
Goal: (MonoidHom.precompEquiv e γ).symm g = g.comp ↑e.symm
-- MonoidHom.fromMultiplicativeIntEquiv_apply
@[simps]
def fromMultiplicativeIntEquiv (α : Type u) [Group α] : (Multiplicative ℤ →* α) ≃ α 
Arguments: (α : Type u) [Group α] (φ : Multiplicative ℤ →* α)
Goal: (MonoidHom.fromMultiplicativeIntEquiv α) φ = φ (Multiplicative.ofAdd 1)
-- MonoidHom.fromMultiplicativeIntEquiv_symm_apply
@[simps]
def fromMultiplicativeIntEquiv (α : Type u) [Group α] : (Multiplicative ℤ →* α) ≃ α 
Arguments: (α : Type u) [Group α] (x : α)
Goal: (MonoidHom.fromMultiplicativeIntEquiv α).symm x = (zpowersHom α) x
-- MonoidHom.fromULiftMultiplicativeIntEquiv_symm_apply_apply
@[simps!]
def fromULiftMultiplicativeIntEquiv (α : Type u) [Group α] :
    (ULift.{u} (Multiplicative ℤ) →* α) ≃ α 
Arguments: (α : Type u) [Group α]
Goal: ∀ (a : α) (a_1 : ULift.{u, 0} (Multiplicative ℤ)),
  ((MonoidHom.fromULiftMultiplicativeIntEquiv α).symm a) a_1 = a ^ Multiplicative.toAdd (MulEquiv.ulift a_1)
-- MonoidHom.fromULiftMultiplicativeIntEquiv_apply
@[simps!]
def fromULiftMultiplicativeIntEquiv (α : Type u) [Group α] :
    (ULift.{u} (Multiplicative ℤ) →* α) ≃ α 
Arguments: (α : Type u) [Group α]
Goal: ∀ (a : ULift.{u, 0} (Multiplicative ℤ) →* α),
  (MonoidHom.fromULiftMultiplicativeIntEquiv α) a = a (MulEquiv.ulift.symm (Multiplicative.ofAdd 1))
-- AddMonoidHom.precompEquiv_symm_apply
@[simps]
def precompEquiv {α β : Type*} [AddMonoid α] [AddMonoid β] (e : α ≃+ β) (γ : Type*) [AddMonoid γ] :
    (β →+ γ) ≃ (α →+ γ) 
Arguments: {α : Type u_1} {β : Type u_2} [AddMonoid α] [AddMonoid β] (e : α ≃+ β) (γ : Type u_3) [AddMonoid γ] (g : α →+ γ)
Goal: (AddMonoidHom.precompEquiv e γ).symm g = g.comp ↑e.symm
-- AddMonoidHom.precompEquiv_apply
@[simps]
def precompEquiv {α β : Type*} [AddMonoid α] [AddMonoid β] (e : α ≃+ β) (γ : Type*) [AddMonoid γ] :
    (β →+ γ) ≃ (α →+ γ) 
Arguments: {α : Type u_1} {β : Type u_2} [AddMonoid α] [AddMonoid β] (e : α ≃+ β) (γ : Type u_3) [AddMonoid γ] (f : β →+ γ)
Goal: (AddMonoidHom.precompEquiv e γ) f = f.comp ↑e
-- AddMonoidHom.fromIntEquiv_apply
@[simps]
def fromIntEquiv (α : Type u) [AddGroup α] : (ℤ →+ α) ≃ α 
Arguments: (α : Type u) [AddGroup α] (φ : ℤ →+ α)
Goal: (AddMonoidHom.fromIntEquiv α) φ = φ 1
-- AddMonoidHom.fromIntEquiv_symm_apply
@[simps]
def fromIntEquiv (α : Type u) [AddGroup α] : (ℤ →+ α) ≃ α 
Arguments: (α : Type u) [AddGroup α] (x : α)
Goal: (AddMonoidHom.fromIntEquiv α).symm x = (zmultiplesHom α) x
-- AddMonoidHom.fromULiftIntEquiv_symm_apply_apply
@[simps!]
def fromULiftIntEquiv (α : Type u) [AddGroup α] : (ULift.{u} ℤ →+ α) ≃ α 
Arguments: (α : Type u) [AddGroup α]
Goal: ∀ (a : α) (a_1 : ULift.{u, 0} ℤ), ((AddMonoidHom.fromULiftIntEquiv α).symm a) a_1 = AddEquiv.ulift a_1 • a
-- AddMonoidHom.fromULiftIntEquiv_apply
@[simps!]
def fromULiftIntEquiv (α : Type u) [AddGroup α] : (ULift.{u} ℤ →+ α) ≃ α 
Arguments: (α : Type u) [AddGroup α]
Goal: ∀ (a : ULift.{u, 0} ℤ →+ α), (AddMonoidHom.fromULiftIntEquiv α) a = a (AddEquiv.ulift.symm 1)
-- AddCommGrp.binaryProductLimitCone_cone_pt
@[simps cone_pt isLimit_lift]
def binaryProductLimitCone (G H : AddCommGrp.{u}) : Limits.LimitCone (pair G H) 
Arguments: (G H : AddCommGrp)
Goal: (G.binaryProductLimitCone H).cone.pt = AddCommGrp.of (↑G × ↑H)
-- AddCommGrp.binaryProductLimitCone_isLimit_lift
@[simps cone_pt isLimit_lift]
def binaryProductLimitCone (G H : AddCommGrp.{u}) : Limits.LimitCone (pair G H) 
Arguments: (G H : AddCommGrp) (s : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair G H))
Goal: (G.binaryProductLimitCone H).isLimit.lift s =
  AddMonoidHom.prod (s.π.app { as := CategoryTheory.Limits.WalkingPair.left })
    (s.π.app { as := CategoryTheory.Limits.WalkingPair.right })
-- AddCommGrp.binaryProductLimitCone_cone_π_app_left
@[simp]
theorem binaryProductLimitCone_cone_π_app_left (G H : AddCommGrp.{u}) :
    (binaryProductLimitCone G H).cone.π.app ⟨WalkingPair.left⟩ = AddMonoidHom.fst G H 
Arguments: (G H : AddCommGrp)
Goal: (G.binaryProductLimitCone H).cone.π.app { as := CategoryTheory.Limits.WalkingPair.left } = AddMonoidHom.fst ↑G ↑H
-- AddCommGrp.binaryProductLimitCone_cone_π_app_right
@[simp]
theorem binaryProductLimitCone_cone_π_app_right (G H : AddCommGrp.{u}) :
    (binaryProductLimitCone G H).cone.π.app ⟨WalkingPair.right⟩ = AddMonoidHom.snd G H 
Arguments: (G H : AddCommGrp)
Goal: (G.binaryProductLimitCone H).cone.π.app { as := CategoryTheory.Limits.WalkingPair.right } = AddMonoidHom.snd ↑G ↑H
-- AddCommGrp.biprodIsoProd_hom_apply
@[simps! hom_apply]
noncomputable def biprodIsoProd (G H : AddCommGrp.{u}) :
    (G ⊞ H : AddCommGrp) ≅ AddCommGrp.of (G × H) 
Arguments: (G H : AddCommGrp) (i : ↑(CategoryTheory.Limits.BinaryBiproduct.bicone G H).toCone.pt)
Goal: (G.biprodIsoProd H).hom i = (CategoryTheory.Limits.biprod.fst i, CategoryTheory.Limits.biprod.snd i)
-- AddCommGrp.biprodIsoProd_inv_comp_fst
@[simp, elementwise]
theorem biprodIsoProd_inv_comp_fst (G H : AddCommGrp.{u}) :
    (biprodIsoProd G H).inv ≫ biprod.fst = AddMonoidHom.fst G H 
Arguments: (G H : AddCommGrp)
Goal: (G.biprodIsoProd H).inv ≫ CategoryTheory.Limits.biprod.fst = AddMonoidHom.fst ↑G ↑H
-- AddCommGrp.biprodIsoProd_inv_comp_snd
@[simp, elementwise]
theorem biprodIsoProd_inv_comp_snd (G H : AddCommGrp.{u}) :
    (biprodIsoProd G H).inv ≫ biprod.snd = AddMonoidHom.snd G H 
Arguments: (G H : AddCommGrp)
Goal: (G.biprodIsoProd H).inv ≫ CategoryTheory.Limits.biprod.snd = AddMonoidHom.snd ↑G ↑H
-- AddCommGrp.HasLimit.productLimitCone_cone_π
@[simps]
def productLimitCone : Limits.LimitCone (Discrete.functor f) 
Arguments: {J : Type w} (f : J → AddCommGrp)
Goal: (AddCommGrp.HasLimit.productLimitCone f).cone.π =
  CategoryTheory.Discrete.natTrans fun j => Pi.evalAddMonoidHom (fun j => ↑(f j)) j.as
-- AddCommGrp.HasLimit.productLimitCone_cone_pt
@[simps]
def productLimitCone : Limits.LimitCone (Discrete.functor f) 
Arguments: {J : Type w} (f : J → AddCommGrp)
Goal: (AddCommGrp.HasLimit.productLimitCone f).cone.pt = AddCommGrp.of ((j : J) → ↑(f j))
-- AddCommGrp.HasLimit.productLimitCone_isLimit_lift
@[simps]
def productLimitCone : Limits.LimitCone (Discrete.functor f) 
Arguments: {J : Type w} (f : J → AddCommGrp) (s : CategoryTheory.Limits.Fan f)
Goal: (AddCommGrp.HasLimit.productLimitCone f).isLimit.lift s = AddCommGrp.HasLimit.lift f s
-- AddCommGrp.biproductIsoPi_hom_apply
@[simps! hom_apply]
noncomputable def biproductIsoPi (f : J → AddCommGrp.{u}) :
    (⨁ f : AddCommGrp) ≅ AddCommGrp.of (∀ j, f j) 
Arguments: {J : Type} [Finite J] (f : J → AddCommGrp) (x : ↑(CategoryTheory.Limits.biproduct.bicone f).toCone.pt) (j : J)
Goal: (AddCommGrp.biproductIsoPi f).hom x j = (CategoryTheory.Limits.biproduct.π f j) x
-- AddCommGrp.biproductIsoPi_inv_comp_π
@[simp, elementwise]
theorem biproductIsoPi_inv_comp_π (f : J → AddCommGrp.{u}) (j : J) :
    (biproductIsoPi f).inv ≫ biproduct.π f j = Pi.evalAddMonoidHom (fun j => f j) j 
Arguments: {J : Type} [Finite J] (f : J → AddCommGrp) (j : J)
Goal: (AddCommGrp.biproductIsoPi f).inv ≫ CategoryTheory.Limits.biproduct.π f j = Pi.evalAddMonoidHom (fun j => ↑(f j)) j
-- PresheafOfModules.limitBundledCore_map
@[simps]
noncomputable def limitBundledCore : BundledCorePresheafOfModules R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {J : Type u₂} [CategoryTheory.Category.{v₂, u₂} J] (F : J ⥤ PresheafOfModules R) [∀ (X : Cᵒᵖ),
    Small.{v, max u₂ v}
      ↑((F ⋙ PresheafOfModules.evaluation R X) ⋙ CategoryTheory.forget (ModuleCat ↑(R.obj X))).sections] {X Y : Cᵒᵖ} (f : X ⟶ Y)
Goal: (PresheafOfModules.limitBundledCore F).map f =
  CategoryTheory.Limits.limMap (CategoryTheory.whiskerLeft F (PresheafOfModules.restriction R f)) ≫
    (CategoryTheory.preservesLimitIso (ModuleCat.restrictScalars (R.map f)) (F ⋙ PresheafOfModules.evaluation R Y)).inv
-- PresheafOfModules.limitBundledCore_obj
@[simps]
noncomputable def limitBundledCore : BundledCorePresheafOfModules R 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {J : Type u₂} [CategoryTheory.Category.{v₂, u₂} J] (F : J ⥤ PresheafOfModules R) [∀ (X : Cᵒᵖ),
    Small.{v, max u₂ v}
      ↑((F ⋙ PresheafOfModules.evaluation R X) ⋙ CategoryTheory.forget (ModuleCat ↑(R.obj X))).sections] (X : Cᵒᵖ)
Goal: (PresheafOfModules.limitBundledCore F).obj X = CategoryTheory.Limits.limit (F ⋙ PresheafOfModules.evaluation R X)
-- PresheafOfModules.limitConeπApp_naturality
@[reassoc (attr := simp)]
lemma limitConeπApp_naturality {i j : J} (f : i ⟶ j) :
    limitConeπApp F i ≫ F.map f = limitConeπApp F j 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {J : Type u₂} [CategoryTheory.Category.{v₂, u₂} J] (F : J ⥤ PresheafOfModules R) [∀ (X : Cᵒᵖ),
    Small.{v, max u₂ v}
      ↑((F ⋙ PresheafOfModules.evaluation R X) ⋙ CategoryTheory.forget (ModuleCat ↑(R.obj X))).sections] {i j : J} (f : i ⟶ j)
Goal: PresheafOfModules.limitConeπApp F i ≫ F.map f = PresheafOfModules.limitConeπApp F j
-- PresheafOfModules.limitCone_pt
@[simps]
noncomputable def limitCone : Cone F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {J : Type u₂} [CategoryTheory.Category.{v₂, u₂} J] (F : J ⥤ PresheafOfModules R) [∀ (X : Cᵒᵖ),
    Small.{v, max u₂ v}
      ↑((F ⋙ PresheafOfModules.evaluation R X) ⋙ CategoryTheory.forget (ModuleCat ↑(R.obj X))).sections]
Goal: (PresheafOfModules.limitCone F).pt = (PresheafOfModules.limitBundledCore F).toPresheafOfModules
-- PresheafOfModules.limitCone_π_app
@[simps]
noncomputable def limitCone : Cone F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {J : Type u₂} [CategoryTheory.Category.{v₂, u₂} J] (F : J ⥤ PresheafOfModules R) [∀ (X : Cᵒᵖ),
    Small.{v, max u₂ v}
      ↑((F ⋙ PresheafOfModules.evaluation R X) ⋙ CategoryTheory.forget (ModuleCat ↑(R.obj X))).sections] (j : J)
Goal: (PresheafOfModules.limitCone F).π.app j = PresheafOfModules.limitConeπApp F j
-- SemiRingCat.coe_id
lemma coe_id {X : SemiRingCat} : (𝟙 X : X → X) = id 
Arguments: {X : SemiRingCat}
Goal: ⇑(𝟙 X) = id
-- SemiRingCat.coe_comp
lemma coe_comp {X Y Z : SemiRingCat} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
Arguments: {X Y Z : SemiRingCat} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f
-- SemiRingCat.forget_map
@[simp] lemma forget_map {X Y : SemiRingCat} (f : X ⟶ Y) :
    (forget SemiRingCat).map f = (f : X → Y) 
Arguments: {X Y : SemiRingCat} (f : X ⟶ Y)
Goal: (CategoryTheory.forget SemiRingCat).map f = ⇑f
-- SemiRingCat.ext
lemma ext {X Y : SemiRingCat} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g 
Arguments: {X Y : SemiRingCat} {f g : X ⟶ Y} (w : ∀ (x : ↑X), f x = g x)
Goal: f = g
-- SemiRingCat.coe_of
@[simp]
theorem coe_of (R : Type u) [Semiring R] : (SemiRingCat.of R : Type u) = R 
Arguments: (R : Type u) [Semiring R]
Goal: ↑(SemiRingCat.of R) = R
-- SemiRingCat.coe_ringHom_id
@[simp] theorem coe_ringHom_id {X : SemiRingCat} :
    @DFunLike.coe (X →+* X) X (fun _ ↦ X) _ (𝟙 X) = id 
Arguments: {X : SemiRingCat}
Goal: ⇑(𝟙 X) = id
-- SemiRingCat.coe_id_of
@[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) 
Arguments: {X : Type u} [Semiring X]
Goal: ⇑(𝟙 (SemiRingCat.of X)) = ⇑(RingHom.id X)
-- SemiRingCat.coe_comp_of
@[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) 
Arguments: {X Y Z : Type u} [Semiring X] [Semiring Y] [Semiring Z] (f : X →+* Y) (g : Y →+* Z)
Goal: ⇑(f ≫ g) = ⇑(g.comp f)
-- SemiRingCat.ext_of
@[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 
Arguments: {X Y : Type u} [Semiring X] [Semiring Y] (f g : X →+* Y) (h : ∀ (x : X), f x = g x)
Goal: f = g
-- SemiRingCat.RingEquiv_coe_eq
@[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 
Arguments: {X Y : Type u_1} [Semiring X] [Semiring Y] (e : X ≃+* Y)
Goal: ⇑↑e = ⇑e
-- SemiRingCat.ofHom_apply
@[simp, nolint simpNF]
theorem ofHom_apply {R S : Type u} [Semiring R] [Semiring S] (f : R →+* S) (x : R) :
    ofHom f x = f x 
Arguments: {R S : Type u} [Semiring R] [Semiring S] (f : R →+* S) (x : R)
Goal: (SemiRingCat.ofHom f) x = f x
-- RingEquiv.toSemiRingCatIso_inv
@[simps]
def _root_.RingEquiv.toSemiRingCatIso {X Y : Type u} [Semiring X] [Semiring Y] (e : X ≃+* Y) :
    SemiRingCat.of X ≅ SemiRingCat.of Y 
Arguments: {X Y : Type u} [Semiring X] [Semiring Y] (e : X ≃+* Y)
Goal: e.toSemiRingCatIso.inv = e.symm.toRingHom
-- RingEquiv.toSemiRingCatIso_hom
@[simps]
def _root_.RingEquiv.toSemiRingCatIso {X Y : Type u} [Semiring X] [Semiring Y] (e : X ≃+* Y) :
    SemiRingCat.of X ≅ SemiRingCat.of Y 
Arguments: {X Y : Type u} [Semiring X] [Semiring Y] (e : X ≃+* Y)
Goal: e.toSemiRingCatIso.hom = e.toRingHom
-- RingCat.coe_id
lemma coe_id {X : RingCat} : (𝟙 X : X → X) = id 
Arguments: {X : RingCat}
Goal: ⇑(𝟙 X) = id
-- RingCat.coe_comp
lemma coe_comp {X Y Z : RingCat} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
Arguments: {X Y Z : RingCat} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f
-- RingCat.forget_map
@[simp] lemma forget_map {X Y : RingCat} (f : X ⟶ Y) : (forget RingCat).map f = (f : X → Y) 
Arguments: {X Y : RingCat} (f : X ⟶ Y)
Goal: (CategoryTheory.forget RingCat).map f = ⇑f
-- RingCat.ext
lemma ext {X Y : RingCat} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g 
Arguments: {X Y : RingCat} {f g : X ⟶ Y} (w : ∀ (x : ↑X), f x = g x)
Goal: f = g
-- RingCat.coe_of
@[simp]
theorem coe_of (R : Type u) [Ring R] : (RingCat.of R : Type u) = R 
Arguments: (R : Type u) [Ring R]
Goal: ↑(RingCat.of R) = R
-- RingCat.coe_ringHom_id
@[simp] theorem coe_ringHom_id {X : RingCat} :
    @DFunLike.coe (X →+* X) X (fun _ ↦ X) _ (𝟙 X) = id 
Arguments: {X : RingCat}
Goal: ⇑(𝟙 X) = id
-- RingCat.coe_id_of
@[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) 
Arguments: {X : Type u} [Ring X]
Goal: ⇑(𝟙 (RingCat.of X)) = ⇑(RingHom.id X)
-- RingCat.coe_comp_of
@[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) 
Arguments: {X Y Z : Type u} [Ring X] [Ring Y] [Ring Z] (f : X →+* Y) (g : Y →+* Z)
Goal: ⇑(f ≫ g) = ⇑(g.comp f)
-- RingCat.ext_of
@[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 
Arguments: {X Y : Type u} [Ring X] [Ring Y] (f g : X →+* Y) (h : ∀ (x : X), f x = g x)
Goal: f = g
-- RingCat.RingEquiv_coe_eq
@[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 
Arguments: {X Y : Type u_1} [Ring X] [Ring Y] (e : X ≃+* Y)
Goal: ⇑↑e = ⇑e
-- CommSemiRingCat.coe_id
lemma coe_id {X : CommSemiRingCat} : (𝟙 X : X → X) = id 
Arguments: {X : CommSemiRingCat}
Goal: ⇑(𝟙 X) = id
-- CommSemiRingCat.coe_comp
lemma coe_comp {X Y Z : CommSemiRingCat} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
Arguments: {X Y Z : CommSemiRingCat} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f
-- CommSemiRingCat.forget_map
@[simp] lemma forget_map {X Y : CommSemiRingCat} (f : X ⟶ Y) :
  (forget CommSemiRingCat).map f = (f : X → Y) 
Arguments: {X Y : CommSemiRingCat} (f : X ⟶ Y)
Goal: (CategoryTheory.forget CommSemiRingCat).map f = ⇑f
-- CommSemiRingCat.ext
lemma ext {X Y : CommSemiRingCat} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g 
Arguments: {X Y : CommSemiRingCat} {f g : X ⟶ Y} (w : ∀ (x : ↑X), f x = g x)
Goal: f = g
-- CommSemiRingCat.RingEquiv_coe_eq
@[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 
Arguments: {X Y : Type u_1} [CommSemiring X] [CommSemiring Y] (e : X ≃+* Y)
Goal: ⇑↑e = ⇑e
-- CommSemiRingCat.coe_of
@[simp]
theorem coe_of (R : Type u) [CommSemiring R] : (CommSemiRingCat.of R : Type u) = R 
Arguments: (R : Type u) [CommSemiring R]
Goal: ↑(CommSemiRingCat.of R) = R
-- CommSemiRingCat.coe_ringHom_id
@[simp] theorem coe_ringHom_id {X : CommSemiRingCat} :
    @DFunLike.coe (X →+* X) X (fun _ ↦ X) _ (𝟙 X) = id 
Arguments: {X : CommSemiRingCat}
Goal: ⇑(𝟙 X) = id
-- CommSemiRingCat.coe_id_of
@[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) 
Arguments: {X : Type u} [CommSemiring X]
Goal: ⇑(𝟙 (CommSemiRingCat.of X)) = ⇑(RingHom.id X)
-- CommSemiRingCat.coe_comp_of
@[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) 
Arguments: {X Y Z : Type u} [CommSemiring X] [CommSemiring Y] [CommSemiring Z] (f : X →+* Y) (g : Y →+* Z)
Goal: ⇑(f ≫ g) = ⇑(g.comp f)
-- CommSemiRingCat.ext_of
@[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 
Arguments: {X Y : Type u} [CommSemiring X] [CommSemiring Y] (f g : X →+* Y) (h : ∀ (x : X), f x = g x)
Goal: f = g
-- RingEquiv.toCommSemiRingCatIso_hom
@[simps]
def _root_.RingEquiv.toCommSemiRingCatIso {X Y : Type u} [CommSemiring X] [CommSemiring Y]
    (e : X ≃+* Y) : CommSemiRingCat.of X ≅ CommSemiRingCat.of Y 
Arguments: {X Y : Type u} [CommSemiring X] [CommSemiring Y] (e : X ≃+* Y)
Goal: e.toCommSemiRingCatIso.hom = e.toRingHom
-- RingEquiv.toCommSemiRingCatIso_inv
@[simps]
def _root_.RingEquiv.toCommSemiRingCatIso {X Y : Type u} [CommSemiring X] [CommSemiring Y]
    (e : X ≃+* Y) : CommSemiRingCat.of X ≅ CommSemiRingCat.of Y 
Arguments: {X Y : Type u} [CommSemiring X] [CommSemiring Y] (e : X ≃+* Y)
Goal: e.toCommSemiRingCatIso.inv = e.symm.toRingHom
-- CommRingCat.coe_id
lemma coe_id {X : CommRingCat} : (𝟙 X : X → X) = id 
Arguments: {X : CommRingCat}
Goal: ⇑(𝟙 X) = id
-- CommRingCat.coe_comp
lemma coe_comp {X Y Z : CommRingCat} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
Arguments: {X Y Z : CommRingCat} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f
-- CommRingCat.id_apply
@[simp] lemma id_apply (R : CommRingCat) (x : R) : 𝟙 R x = x 
Arguments: (R : CommRingCat) (x : ↑R)
Goal: (𝟙 R) x = x
-- CommRingCat.comp_apply
@[simp]
theorem comp_apply {R S T : CommRingCat} (f : R ⟶ S) (g : S ⟶ T) (x : R) :
    (f ≫ g) x = g (f x) 
Arguments: {R S T : CommRingCat} (f : R ⟶ S) (g : S ⟶ T) (x : ↑R)
Goal: (f ≫ g) x = g (f x)
-- CommRingCat.forget_obj
@[simp] theorem forget_obj (R : CommRingCat) : (forget _).obj R = R 
Arguments: (R : CommRingCat)
Goal: (CategoryTheory.forget CommRingCat).obj R = ↑R
-- CommRingCat.forget_map
@[simp] lemma forget_map {X Y : CommRingCat} (f : X ⟶ Y) :
    (forget CommRingCat).map f = (f : X → Y) 
Arguments: {X Y : CommRingCat} (f : X ⟶ Y)
Goal: (CategoryTheory.forget CommRingCat).map f = ⇑f