ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CommRingCat.ext
lemma ext {X Y : CommRingCat} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g 
Arguments: {X Y : CommRingCat} {f g : X ⟶ Y} (w : ∀ (x : ↑X), f x = g x)
Goal: f = g
-- CommRingCat.RingEquiv_coe_eq
@[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 
Arguments: {X Y : Type u_1} [CommRing X] [CommRing Y] (e : X ≃+* Y)
Goal: ⇑↑e = ⇑e
-- CommRingCat.coe_of
@[simp]
theorem coe_of (R : Type u) [CommRing R] : (CommRingCat.of R : Type u) = R 
Arguments: (R : Type u) [CommRing R]
Goal: ↑(CommRingCat.of R) = R
-- CommRingCat.coe_ringHom_id
@[simp] theorem coe_ringHom_id {X : CommRingCat} :
    @DFunLike.coe (X →+* X) X (fun _ ↦ X) _ (𝟙 X) = id 
Arguments: {X : CommRingCat}
Goal: ⇑(𝟙 X) = id
-- CommRingCat.coe_id_of
@[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) 
Arguments: {X : Type u} [CommRing X]
Goal: ⇑(𝟙 (CommRingCat.of X)) = ⇑(RingHom.id X)
-- CommRingCat.coe_comp_of
@[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) 
Arguments: {X Y Z : Type u} [CommRing X] [CommRing Y] [CommRing Z] (f : X →+* Y) (g : Y →+* Z)
Goal: ⇑(f ≫ g) = ⇑(g.comp f)
-- CommRingCat.ext_of
@[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 
Arguments: {X Y : Type u} [CommRing X] [CommRing Y] (f g : X →+* Y) (h : ∀ (x : X), f x = g x)
Goal: f = g
-- RingEquiv.toRingCatIso_inv
@[simps]
def toRingCatIso [Ring X] [Ring Y] (e : X ≃+* Y) : RingCat.of X ≅ RingCat.of Y 
Arguments: {X Y : Type u} [Ring X] [Ring Y] (e : X ≃+* Y)
Goal: e.toRingCatIso.inv = e.symm.toRingHom
-- RingEquiv.toRingCatIso_hom
@[simps]
def toRingCatIso [Ring X] [Ring Y] (e : X ≃+* Y) : RingCat.of X ≅ RingCat.of Y 
Arguments: {X Y : Type u} [Ring X] [Ring Y] (e : X ≃+* Y)
Goal: e.toRingCatIso.hom = e.toRingHom
-- RingEquiv.toCommRingCatIso_hom
@[simps]
def toCommRingCatIso [CommRing X] [CommRing Y] (e : X ≃+* Y) :
    CommRingCat.of X ≅ CommRingCat.of Y 
Arguments: {X Y : Type u} [CommRing X] [CommRing Y] (e : X ≃+* Y)
Goal: e.toCommRingCatIso.hom = e.toRingHom
-- RingEquiv.toCommRingCatIso_inv
@[simps]
def toCommRingCatIso [CommRing X] [CommRing Y] (e : X ≃+* Y) :
    CommRingCat.of X ≅ CommRingCat.of Y 
Arguments: {X Y : Type u} [CommRing X] [CommRing Y] (e : X ≃+* Y)
Goal: e.toCommRingCatIso.inv = e.symm.toRingHom
-- CategoryTheory.Iso.commRingIsoToRingEquiv_toRingHom
@[simp (high)]
theorem commRingIsoToRingEquiv_toRingHom {X Y : CommRingCat} (i : X ≅ Y) :
    i.commRingCatIsoToRingEquiv.toRingHom = i.hom 
Arguments: {X Y : CommRingCat} (i : X ≅ Y)
Goal: i.commRingCatIsoToRingEquiv.toRingHom = i.hom
-- CategoryTheory.Iso.commRingIsoToRingEquiv_symm_toRingHom
@[simp (high)]
theorem commRingIsoToRingEquiv_symm_toRingHom {X Y : CommRingCat} (i : X ≅ Y) :
    i.commRingCatIsoToRingEquiv.symm.toRingHom = i.inv 
Arguments: {X Y : CommRingCat} (i : X ≅ Y)
Goal: i.commRingCatIsoToRingEquiv.symm.toRingHom = i.inv
-- CommRingCat.comp_eq_ring_hom_comp
theorem CommRingCat.comp_eq_ring_hom_comp {R S T : CommRingCat} (f : R ⟶ S) (g : S ⟶ T) :
    f ≫ g = g.comp f 
Arguments: {R S T : CommRingCat} (f : R ⟶ S) (g : S ⟶ T)
Goal: f ≫ g = RingHom.comp g f
-- CommRingCat.ringHom_comp_eq_comp
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 
Arguments: {R S T : Type u_1} [CommRing R] [CommRing S] [CommRing T] (f : R →+* S) (g : S →+* T)
Goal: g.comp f = CommRingCat.ofHom f ≫ CommRingCat.ofHom g
-- RingHom.comp_id_semiringCat
@[simp] theorem RingHom.comp_id_semiringCat
    {G : SemiRingCat.{u}} {H : Type u} [Semiring H] (f : G →+* H) : f.comp (𝟙 G) = f 
Arguments: {G : SemiRingCat} {H : Type u} [Semiring H] (f : ↑G →+* H)
Goal: f.comp (𝟙 G) = f
-- RingHom.id_semiringCat_comp
@[simp] theorem RingHom.id_semiringCat_comp
    {G : Type u} [Semiring G] {H : SemiRingCat.{u}} (f : G →+* H) : RingHom.comp (𝟙 H) f = f 
Arguments: {G : Type u} [Semiring G] {H : SemiRingCat} (f : G →+* ↑H)
Goal: RingHom.comp (𝟙 H) f = f
-- RingHom.comp_id_commSemiringCat
@[simp] theorem RingHom.comp_id_commSemiringCat
    {G : CommSemiRingCat.{u}} {H : Type u} [CommSemiring H] (f : G →+* H) : f.comp (𝟙 G) = f 
Arguments: {G : CommSemiRingCat} {H : Type u} [CommSemiring H] (f : ↑G →+* H)
Goal: f.comp (𝟙 G) = f
-- RingHom.id_commSemiringCat_comp
@[simp] theorem RingHom.id_commSemiringCat_comp
    {G : Type u} [CommSemiring G] {H : CommSemiRingCat.{u}} (f : G →+* H) :
    RingHom.comp (𝟙 H) f = f 
Arguments: {G : Type u} [CommSemiring G] {H : CommSemiRingCat} (f : G →+* ↑H)
Goal: RingHom.comp (𝟙 H) f = f
-- RingHom.comp_id_ringCat
@[simp] theorem RingHom.comp_id_ringCat
    {G : RingCat.{u}} {H : Type u} [Ring H] (f : G →+* H) : f.comp (𝟙 G) = f 
Arguments: {G : RingCat} {H : Type u} [Ring H] (f : ↑G →+* H)
Goal: f.comp (𝟙 G) = f
-- RingHom.id_ringCat_comp
@[simp] theorem RingHom.id_ringCat_comp
    {G : Type u} [Ring G] {H : RingCat.{u}} (f : G →+* H) : RingHom.comp (𝟙 H) f = f 
Arguments: {G : Type u} [Ring G] {H : RingCat} (f : G →+* ↑H)
Goal: RingHom.comp (𝟙 H) f = f
-- RingHom.comp_id_commRingCat
@[simp] theorem RingHom.comp_id_commRingCat
    {G : CommRingCat.{u}} {H : Type u} [CommRing H] (f : G →+* H) : f.comp (𝟙 G) = f 
Arguments: {G : CommRingCat} {H : Type u} [CommRing H] (f : ↑G →+* H)
Goal: f.comp (𝟙 G) = f
-- RingHom.id_commRingCat_comp
@[simp] theorem RingHom.id_commRingCat_comp
    {G : Type u} [CommRing G] {H : CommRingCat.{u}} (f : G →+* H) : RingHom.comp (𝟙 H) f = f 
Arguments: {G : Type u} [CommRing G] {H : CommRingCat} (f : G →+* ↑H)
Goal: RingHom.comp (𝟙 H) f = f
-- Grp.toAddGrp_obj
@[simps]
def toAddGrp : Grp ⥤ AddGrp 
Arguments: (X : Grp)
Goal: Grp.toAddGrp.obj X = AddGrp.of (Additive ↑X)
-- Grp.toAddGrp_map
@[simps]
def toAddGrp : Grp ⥤ AddGrp 
Arguments: {X Y : Grp} (a : ↑X →* ↑Y)
Goal: Grp.toAddGrp.map a = MonoidHom.toAdditive a
-- CommGrp.toAddCommGrp_obj
@[simps]
def toAddCommGrp : CommGrp ⥤ AddCommGrp 
Arguments: (X : CommGrp)
Goal: CommGrp.toAddCommGrp.obj X = AddCommGrp.of (Additive ↑X)
-- CommGrp.toAddCommGrp_map
@[simps]
def toAddCommGrp : CommGrp ⥤ AddCommGrp 
Arguments: {X Y : CommGrp} (a : ↑X →* ↑Y)
Goal: CommGrp.toAddCommGrp.map a = MonoidHom.toAdditive a
-- AddGrp.toGrp_map
@[simps]
def toGrp : AddGrp ⥤ Grp 
Arguments: {X Y : AddGrp} (a : ↑X →+ ↑Y)
Goal: AddGrp.toGrp.map a = AddMonoidHom.toMultiplicative a
-- AddGrp.toGrp_obj
@[simps]
def toGrp : AddGrp ⥤ Grp 
Arguments: (X : AddGrp)
Goal: AddGrp.toGrp.obj X = Grp.of (Multiplicative ↑X)
-- AddCommGrp.toCommGrp_obj
@[simps]
def toCommGrp : AddCommGrp ⥤ CommGrp 
Arguments: (X : AddCommGrp)
Goal: AddCommGrp.toCommGrp.obj X = CommGrp.of (Multiplicative ↑X)
-- AddCommGrp.toCommGrp_map
@[simps]
def toCommGrp : AddCommGrp ⥤ CommGrp 
Arguments: {X Y : AddCommGrp} (a : ↑X →+ ↑Y)
Goal: AddCommGrp.toCommGrp.map a = AddMonoidHom.toMultiplicative a
-- AddGrp.coe_id
@[to_additive (attr := simp)]
lemma coe_id {X : Grp} : (𝟙 X : X → X) = id 
Arguments: {X : AddGrp}
Goal: ⇑(𝟙 X) = id
-- Grp.coe_id
@[to_additive (attr := simp)]
lemma coe_id {X : Grp} : (𝟙 X : X → X) = id 
Arguments: {X : Grp}
Goal: ⇑(𝟙 X) = id
-- Grp.coe_comp
@[to_additive (attr := simp)]
lemma coe_comp {X Y Z : Grp} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
Arguments: {X Y Z : Grp} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f
-- AddGrp.coe_comp
@[to_additive (attr := simp)]
lemma coe_comp {X Y Z : Grp} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
Arguments: {X Y Z : AddGrp} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f
-- Grp.comp_def
@[to_additive]
lemma comp_def {X Y Z : Grp} {f : X ⟶ Y} {g : Y ⟶ Z} : f ≫ g = g.comp f 
Arguments: {X Y Z : Grp} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: f ≫ g = MonoidHom.comp g f
-- AddGrp.comp_def
@[to_additive]
lemma comp_def {X Y Z : Grp} {f : X ⟶ Y} {g : Y ⟶ Z} : f ≫ g = g.comp f 
Arguments: {X Y Z : AddGrp} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: f ≫ g = AddMonoidHom.comp g f
-- Grp.forget_map
@[simp] lemma forget_map {X Y : Grp} (f : X ⟶ Y) : (forget Grp).map f = (f : X → Y) 
Arguments: {X Y : Grp} (f : X ⟶ Y)
Goal: (CategoryTheory.forget Grp).map f = ⇑f
-- AddGrp.ext
@[to_additive (attr := ext)]
lemma ext {X Y : Grp} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g 
Arguments: {X Y : AddGrp} {f g : X ⟶ Y} (w : ∀ (x : ↑X), f x = g x)
Goal: f = g
-- Grp.ext
@[to_additive (attr := ext)]
lemma ext {X Y : Grp} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g 
Arguments: {X Y : Grp} {f g : X ⟶ Y} (w : ∀ (x : ↑X), f x = g x)
Goal: f = g
-- AddGrp.coe_of
@[to_additive (attr := simp)]
theorem coe_of (R : Type u) [Group R] : ↑(Grp.of R) = R 
Arguments: (R : Type u) [AddGroup R]
Goal: ↑(AddGrp.of R) = R
-- Grp.coe_of
@[to_additive (attr := simp)]
theorem coe_of (R : Type u) [Group R] : ↑(Grp.of R) = R 
Arguments: (R : Type u) [Group R]
Goal: ↑(Grp.of R) = R
-- Grp.coe_comp'
@[to_additive (attr := simp)]
theorem coe_comp' {G H K : Type _} [Group G] [Group H] [Group K] (f : G →* H) (g : H →* K) :
    @DFunLike.coe (G →* K) G (fun _ ↦ K) MonoidHom.instFunLike (CategoryStruct.comp
      (X := Grp.of G) (Y := Grp.of H) (Z := Grp.of K) f g) = g ∘ f 
Arguments: {G H K : Type u_1} [Group G] [Group H] [Group K] (f : G →* H) (g : H →* K)
Goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f
-- AddGrp.coe_comp'
@[to_additive (attr := simp)]
theorem coe_comp' {G H K : Type _} [Group G] [Group H] [Group K] (f : G →* H) (g : H →* K) :
    @DFunLike.coe (G →* K) G (fun _ ↦ K) MonoidHom.instFunLike (CategoryStruct.comp
      (X := Grp.of G) (Y := Grp.of H) (Z := Grp.of K) f g) = g ∘ f 
Arguments: {G H K : Type u_1} [AddGroup G] [AddGroup H] [AddGroup K] (f : G →+ H) (g : H →+ K)
Goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f
-- Grp.coe_id'
@[to_additive (attr := simp)]
theorem coe_id' {G : Type _} [Group G] :
    @DFunLike.coe (G →* G) G (fun _ ↦ G) MonoidHom.instFunLike
      (CategoryStruct.id (X := Grp.of G)) = id 
Arguments: {G : Type u_1} [Group G]
Goal: ⇑(𝟙 (Grp.of G)) = id
-- AddGrp.coe_id'
@[to_additive (attr := simp)]
theorem coe_id' {G : Type _} [Group G] :
    @DFunLike.coe (G →* G) G (fun _ ↦ G) MonoidHom.instFunLike
      (CategoryStruct.id (X := Grp.of G)) = id 
Arguments: {G : Type u_1} [AddGroup G]
Goal: ⇑(𝟙 (AddGrp.of G)) = id
-- AddGrp.zero_apply
@[to_additive (attr := simp)]
theorem one_apply (G H : Grp) (g : G) : ((1 : G ⟶ H) : G → H) g = 1 
Arguments: (G H : AddGrp) (g : ↑G)
Goal: 0 g = 0
-- Grp.one_apply
@[to_additive (attr := simp)]
theorem one_apply (G H : Grp) (g : G) : ((1 : G ⟶ H) : G → H) g = 1 
Arguments: (G H : Grp) (g : ↑G)
Goal: 1 g = 1
-- Grp.ofHom_apply
@[to_additive]
theorem ofHom_apply {X Y : Type _} [Group X] [Group Y] (f : X →* Y) (x : X) :
    (ofHom f) x = f x 
Arguments: {X Y : Type u_1} [Group X] [Group Y] (f : X →* Y) (x : X)
Goal: (Grp.ofHom f) x = f x
-- AddGrp.ofHom_apply
@[to_additive]
theorem ofHom_apply {X Y : Type _} [Group X] [Group Y] (f : X →* Y) (x : X) :
    (ofHom f) x = f x 
Arguments: {X Y : Type u_1} [AddGroup X] [AddGroup Y] (f : X →+ Y) (x : X)
Goal: (AddGrp.ofHom f) x = f x
-- Grp.uliftFunctor_map
@[to_additive (attr := simps)
  "Universe lift functor for additive groups."]
def uliftFunctor : Grp.{u} ⥤ Grp.{max u v} 
Arguments: {X Y : Grp} (f : X ⟶ Y)
Goal: Grp.uliftFunctor.map f = Grp.ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom))
-- Grp.uliftFunctor_obj
@[to_additive (attr := simps)
  "Universe lift functor for additive groups."]
def uliftFunctor : Grp.{u} ⥤ Grp.{max u v} 
Arguments: (X : Grp)
Goal: Grp.uliftFunctor.obj X = Grp.of (ULift.{v, u} ↑X)
-- AddGrp.uliftFunctor_map
@[to_additive (attr := simps)
  "Universe lift functor for additive groups."]
def uliftFunctor : Grp.{u} ⥤ Grp.{max u v} 
Arguments: {X Y : AddGrp} (f : X ⟶ Y)
Goal: AddGrp.uliftFunctor.map f =
  AddGrp.ofHom (AddEquiv.ulift.symm.toAddMonoidHom.comp (AddMonoidHom.comp f AddEquiv.ulift.toAddMonoidHom))
-- AddGrp.uliftFunctor_obj
@[to_additive (attr := simps)
  "Universe lift functor for additive groups."]
def uliftFunctor : Grp.{u} ⥤ Grp.{max u v} 
Arguments: (X : AddGrp)
Goal: AddGrp.uliftFunctor.obj X = AddGrp.of (ULift.{v, u} ↑X)
-- CommGrp.coe_id
@[to_additive (attr := simp)]
lemma coe_id {X : CommGrp} : (𝟙 X : X → X) = id 
Arguments: {X : CommGrp}
Goal: ⇑(𝟙 X) = id
-- AddCommGrp.coe_id
@[to_additive (attr := simp)]
lemma coe_id {X : CommGrp} : (𝟙 X : X → X) = id 
Arguments: {X : AddCommGrp}
Goal: ⇑(𝟙 X) = id
-- AddCommGrp.coe_comp
@[to_additive (attr := simp)]
lemma coe_comp {X Y Z : CommGrp} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
Arguments: {X Y Z : AddCommGrp} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f
-- CommGrp.coe_comp
@[to_additive (attr := simp)]
lemma coe_comp {X Y Z : CommGrp} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
Arguments: {X Y Z : CommGrp} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f
-- CommGrp.comp_def
@[to_additive]
lemma comp_def {X Y Z : CommGrp} {f : X ⟶ Y} {g : Y ⟶ Z} : f ≫ g = g.comp f 
Arguments: {X Y Z : CommGrp} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: f ≫ g = MonoidHom.comp g f
-- AddCommGrp.comp_def
@[to_additive]
lemma comp_def {X Y Z : CommGrp} {f : X ⟶ Y} {g : Y ⟶ Z} : f ≫ g = g.comp f 
Arguments: {X Y Z : AddCommGrp} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: f ≫ g = AddMonoidHom.comp g f
-- AddCommGrp.forget_map
@[to_additive (attr := simp)]
lemma forget_map {X Y : CommGrp} (f : X ⟶ Y) :
    (forget CommGrp).map f = (f : X → Y) 
Arguments: {X Y : AddCommGrp} (f : X ⟶ Y)
Goal: (CategoryTheory.forget AddCommGrp).map f = ⇑f
-- CommGrp.forget_map
@[to_additive (attr := simp)]
lemma forget_map {X Y : CommGrp} (f : X ⟶ Y) :
    (forget CommGrp).map f = (f : X → Y) 
Arguments: {X Y : CommGrp} (f : X ⟶ Y)
Goal: (CategoryTheory.forget CommGrp).map f = ⇑f
-- CommGrp.ext
@[to_additive (attr := ext)]
lemma ext {X Y : CommGrp} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g 
Arguments: {X Y : CommGrp} {f g : X ⟶ Y} (w : ∀ (x : ↑X), f x = g x)
Goal: f = g
-- AddCommGrp.ext
@[to_additive (attr := ext)]
lemma ext {X Y : CommGrp} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g 
Arguments: {X Y : AddCommGrp} {f g : X ⟶ Y} (w : ∀ (x : ↑X), f x = g x)
Goal: f = g
-- AddCommGrp.coe_of
@[to_additive (attr := simp)]
theorem coe_of (R : Type u) [CommGroup R] : (CommGrp.of R : Type u) = R 
Arguments: (R : Type u) [AddCommGroup R]
Goal: ↑(AddCommGrp.of R) = R
-- CommGrp.coe_of
@[to_additive (attr := simp)]
theorem coe_of (R : Type u) [CommGroup R] : (CommGrp.of R : Type u) = R 
Arguments: (R : Type u) [CommGroup R]
Goal: ↑(CommGrp.of R) = R
-- CommGrp.coe_comp'
@[to_additive (attr := simp)]
theorem coe_comp' {G H K : Type _} [CommGroup G] [CommGroup H] [CommGroup K]
    (f : G →* H) (g : H →* K) :
    @DFunLike.coe (G →* K) G (fun _ ↦ K) MonoidHom.instFunLike (CategoryStruct.comp
      (X := CommGrp.of G) (Y := CommGrp.of H) (Z := CommGrp.of K) f g) = g ∘ f 
Arguments: {G H K : Type u_1} [CommGroup G] [CommGroup H] [CommGroup K] (f : G →* H) (g : H →* K)
Goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f
-- AddCommGrp.coe_comp'
@[to_additive (attr := simp)]
theorem coe_comp' {G H K : Type _} [CommGroup G] [CommGroup H] [CommGroup K]
    (f : G →* H) (g : H →* K) :
    @DFunLike.coe (G →* K) G (fun _ ↦ K) MonoidHom.instFunLike (CategoryStruct.comp
      (X := CommGrp.of G) (Y := CommGrp.of H) (Z := CommGrp.of K) f g) = g ∘ f 
Arguments: {G H K : Type u_1} [AddCommGroup G] [AddCommGroup H] [AddCommGroup K] (f : G →+ H) (g : H →+ K)
Goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f
-- AddCommGrp.coe_id'
@[to_additive (attr := simp)]
theorem coe_id' {G : Type _} [CommGroup G] :
    @DFunLike.coe (G →* G) G (fun _ ↦ G) MonoidHom.instFunLike
      (CategoryStruct.id (X := CommGrp.of G)) = id 
Arguments: {G : Type u_1} [AddCommGroup G]
Goal: ⇑(𝟙 (AddCommGrp.of G)) = id
-- CommGrp.coe_id'
@[to_additive (attr := simp)]
theorem coe_id' {G : Type _} [CommGroup G] :
    @DFunLike.coe (G →* G) G (fun _ ↦ G) MonoidHom.instFunLike
      (CategoryStruct.id (X := CommGrp.of G)) = id 
Arguments: {G : Type u_1} [CommGroup G]
Goal: ⇑(𝟙 (CommGrp.of G)) = id
-- AddCommGrp.zero_apply
@[to_additive (attr := simp)]
theorem one_apply (G H : CommGrp) (g : G) : ((1 : G ⟶ H) : G → H) g = 1 
Arguments: (G H : AddCommGrp) (g : ↑G)
Goal: 0 g = 0
-- CommGrp.one_apply
@[to_additive (attr := simp)]
theorem one_apply (G H : CommGrp) (g : G) : ((1 : G ⟶ H) : G → H) g = 1 
Arguments: (G H : CommGrp) (g : ↑G)
Goal: 1 g = 1
-- CommGrp.ofHom_apply
@[to_additive (attr := simp)]
theorem ofHom_apply {X Y : Type _} [CommGroup X] [CommGroup Y] (f : X →* Y) (x : X) :
    @DFunLike.coe (X →* Y) X (fun _ ↦ Y) _ (ofHom f) x = f x 
Arguments: {X Y : Type u_1} [CommGroup X] [CommGroup Y] (f : X →* Y) (x : X)
Goal: (CommGrp.ofHom f) x = f x
-- AddCommGrp.ofHom_apply
@[to_additive (attr := simp)]
theorem ofHom_apply {X Y : Type _} [CommGroup X] [CommGroup Y] (f : X →* Y) (x : X) :
    @DFunLike.coe (X →* Y) X (fun _ ↦ Y) _ (ofHom f) x = f x 
Arguments: {X Y : Type u_1} [AddCommGroup X] [AddCommGroup Y] (f : X →+ Y) (x : X)
Goal: (AddCommGrp.ofHom f) x = f x
-- CommGrp.uliftFunctor_map
@[to_additive (attr := simps)
  "Universe lift functor for additive commutative groups."]
def uliftFunctor : CommGrp.{u} ⥤ CommGrp.{max u v} 
Arguments: {X Y : CommGrp} (f : X ⟶ Y)
Goal: CommGrp.uliftFunctor.map f =
  CommGrp.ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom))
-- CommGrp.uliftFunctor_obj
@[to_additive (attr := simps)
  "Universe lift functor for additive commutative groups."]
def uliftFunctor : CommGrp.{u} ⥤ CommGrp.{max u v} 
Arguments: (X : CommGrp)
Goal: CommGrp.uliftFunctor.obj X = CommGrp.of (ULift.{v, u} ↑X)
-- AddCommGrp.uliftFunctor_map
@[to_additive (attr := simps)
  "Universe lift functor for additive commutative groups."]
def uliftFunctor : CommGrp.{u} ⥤ CommGrp.{max u v} 
Arguments: {X Y : AddCommGrp} (f : X ⟶ Y)
Goal: AddCommGrp.uliftFunctor.map f =
  AddCommGrp.ofHom (AddEquiv.ulift.symm.toAddMonoidHom.comp (AddMonoidHom.comp f AddEquiv.ulift.toAddMonoidHom))
-- AddCommGrp.uliftFunctor_obj
@[to_additive (attr := simps)
  "Universe lift functor for additive commutative groups."]
def uliftFunctor : CommGrp.{u} ⥤ CommGrp.{max u v} 
Arguments: (X : AddCommGrp)
Goal: AddCommGrp.uliftFunctor.obj X = AddCommGrp.of (ULift.{v, u} ↑X)
-- AddCommGrp.asHom_apply
@[simp]
theorem asHom_apply {G : AddCommGrp.{0}} (g : G) (i : ℤ) :
    @DFunLike.coe (ℤ →+ ↑G) ℤ (fun _ ↦ ↑G) _ (asHom g) i = i • g 
Arguments: {G : AddCommGrp} (g : ↑G) (i : ℤ)
Goal: (AddCommGrp.asHom g) i = i • g
-- AddCommGrp.asHom_injective
theorem asHom_injective {G : AddCommGrp.{0}} : Function.Injective (@asHom G) 
Arguments: {G : AddCommGrp}
Goal: Function.Injective AddCommGrp.asHom
-- AddCommGrp.int_hom_ext
@[ext]
theorem int_hom_ext {G : AddCommGrp.{0}} (f g : AddCommGrp.of ℤ ⟶ G)
    (w : f (1 : ℤ) = g (1 : ℤ)) : f = g 
Arguments: {G : AddCommGrp} (f g : AddCommGrp.of ℤ ⟶ G) (w : f 1 = g 1)
Goal: f = g
-- AddCommGrp.injective_of_mono
theorem injective_of_mono {G H : AddCommGrp.{0}} (f : G ⟶ H) [Mono f] : Function.Injective f 
Arguments: {G H : AddCommGrp} (f : G ⟶ H) [CategoryTheory.Mono f]
Goal: Function.Injective ⇑f
-- AddEquiv.toAddGrpIso_hom
@[to_additive (attr := simps)]
def MulEquiv.toGrpIso {X Y : Grp} (e : X ≃* Y) : X ≅ Y 
Arguments: {X Y : AddGrp} (e : ↑X ≃+ ↑Y)
Goal: e.toAddGrpIso.hom = e.toAddMonoidHom
-- MulEquiv.toGrpIso_inv
@[to_additive (attr := simps)]
def MulEquiv.toGrpIso {X Y : Grp} (e : X ≃* Y) : X ≅ Y 
Arguments: {X Y : Grp} (e : ↑X ≃* ↑Y)
Goal: e.toGrpIso.inv = e.symm.toMonoidHom
-- MulEquiv.toGrpIso_hom
@[to_additive (attr := simps)]
def MulEquiv.toGrpIso {X Y : Grp} (e : X ≃* Y) : X ≅ Y 
Arguments: {X Y : Grp} (e : ↑X ≃* ↑Y)
Goal: e.toGrpIso.hom = e.toMonoidHom
-- AddEquiv.toAddGrpIso_inv
@[to_additive (attr := simps)]
def MulEquiv.toGrpIso {X Y : Grp} (e : X ≃* Y) : X ≅ Y 
Arguments: {X Y : AddGrp} (e : ↑X ≃+ ↑Y)
Goal: e.toAddGrpIso.inv = e.symm.toAddMonoidHom
-- MulEquiv.toCommGrpIso_inv
@[to_additive (attr := simps)]
def MulEquiv.toCommGrpIso {X Y : CommGrp} (e : X ≃* Y) : X ≅ Y 
Arguments: {X Y : CommGrp} (e : ↑X ≃* ↑Y)
Goal: e.toCommGrpIso.inv = e.symm.toMonoidHom
-- AddEquiv.toAddCommGrpIso_hom
@[to_additive (attr := simps)]
def MulEquiv.toCommGrpIso {X Y : CommGrp} (e : X ≃* Y) : X ≅ Y 
Arguments: {X Y : AddCommGrp} (e : ↑X ≃+ ↑Y)
Goal: e.toAddCommGrpIso.hom = e.toAddMonoidHom
-- MulEquiv.toCommGrpIso_hom
@[to_additive (attr := simps)]
def MulEquiv.toCommGrpIso {X Y : CommGrp} (e : X ≃* Y) : X ≅ Y 
Arguments: {X Y : CommGrp} (e : ↑X ≃* ↑Y)
Goal: e.toCommGrpIso.hom = e.toMonoidHom
-- AddEquiv.toAddCommGrpIso_inv
@[to_additive (attr := simps)]
def MulEquiv.toCommGrpIso {X Y : CommGrp} (e : X ≃* Y) : X ≅ Y 
Arguments: {X Y : AddCommGrp} (e : ↑X ≃+ ↑Y)
Goal: e.toAddCommGrpIso.inv = e.symm.toAddMonoidHom
-- CategoryTheory.Iso.commGroupIsoToMulEquiv_symm_apply
@[to_additive (attr := simps!)]
def commGroupIsoToMulEquiv {X Y : CommGrp} (i : X ≅ Y) : X ≃* Y 
Arguments: {X Y : CommGrp} (i : X ≅ Y) (a : ↑Y)
Goal: i.commGroupIsoToMulEquiv.symm a = i.inv a
-- CategoryTheory.Iso.commGroupIsoToMulEquiv_apply
@[to_additive (attr := simps!)]
def commGroupIsoToMulEquiv {X Y : CommGrp} (i : X ≅ Y) : X ≃* Y 
Arguments: {X Y : CommGrp} (i : X ≅ Y) (a : ↑X)
Goal: i.commGroupIsoToMulEquiv a = i.hom a
-- CategoryTheory.Iso.addCommGroupIsoToAddEquiv_symm_apply
@[to_additive (attr := simps!)]
def commGroupIsoToMulEquiv {X Y : CommGrp} (i : X ≅ Y) : X ≃* Y 
Arguments: {X Y : AddCommGrp} (i : X ≅ Y) (a : ↑Y)
Goal: i.addCommGroupIsoToAddEquiv.symm a = i.inv a
-- CategoryTheory.Iso.addCommGroupIsoToAddEquiv_apply
@[to_additive (attr := simps!)]
def commGroupIsoToMulEquiv {X Y : CommGrp} (i : X ≅ Y) : X ≃* Y 
Arguments: {X Y : AddCommGrp} (i : X ≅ Y) (a : ↑X)
Goal: i.addCommGroupIsoToAddEquiv a = i.hom a
-- AddMonoidHom.comp_id_addGrp
@[to_additive (attr := simp)] theorem MonoidHom.comp_id_grp
    {G : Grp.{u}} {H : Type u} [Group H] (f : G →* H) : f.comp (𝟙 G) = f 
Arguments: {G : AddGrp} {H : Type u} [AddGroup H] (f : ↑G →+ H)
Goal: f.comp (𝟙 G) = f
-- MonoidHom.comp_id_grp
@[to_additive (attr := simp)] theorem MonoidHom.comp_id_grp
    {G : Grp.{u}} {H : Type u} [Group H] (f : G →* H) : f.comp (𝟙 G) = f 
Arguments: {G : Grp} {H : Type u} [Group H] (f : ↑G →* H)
Goal: f.comp (𝟙 G) = f
-- AddMonoidHom.id_addGrp_comp
@[to_additive (attr := simp)] theorem MonoidHom.id_grp_comp
    {G : Type u} [Group G] {H : Grp.{u}} (f : G →* H) : MonoidHom.comp (𝟙 H) f = f 
Arguments: {G : Type u} [AddGroup G] {H : AddGrp} (f : G →+ ↑H)
Goal: AddMonoidHom.comp (𝟙 H) f = f
-- MonoidHom.id_grp_comp
@[to_additive (attr := simp)] theorem MonoidHom.id_grp_comp
    {G : Type u} [Group G] {H : Grp.{u}} (f : G →* H) : MonoidHom.comp (𝟙 H) f = f 
Arguments: {G : Type u} [Group G] {H : Grp} (f : G →* ↑H)
Goal: MonoidHom.comp (𝟙 H) f = f
-- AddMonoidHom.comp_id_addCommGrp
@[to_additive (attr := simp)] theorem MonoidHom.comp_id_commGrp
    {G : CommGrp.{u}} {H : Type u} [CommGroup H] (f : G →* H) : f.comp (𝟙 G) = f 
Arguments: {G : AddCommGrp} {H : Type u} [AddCommGroup H] (f : ↑G →+ H)
Goal: f.comp (𝟙 G) = f
-- MonoidHom.comp_id_commGrp
@[to_additive (attr := simp)] theorem MonoidHom.comp_id_commGrp
    {G : CommGrp.{u}} {H : Type u} [CommGroup H] (f : G →* H) : f.comp (𝟙 G) = f 
Arguments: {G : CommGrp} {H : Type u} [CommGroup H] (f : ↑G →* H)
Goal: f.comp (𝟙 G) = f
-- MonoidHom.id_commGrp_comp
@[to_additive (attr := simp)] theorem MonoidHom.id_commGrp_comp
    {G : Type u} [CommGroup G] {H : CommGrp.{u}} (f : G →* H) : MonoidHom.comp (𝟙 H) f = f 
Arguments: {G : Type u} [CommGroup G] {H : CommGrp} (f : G →* ↑H)
Goal: MonoidHom.comp (𝟙 H) f = f