ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- ModuleCat.span_rightExact
theorem span_rightExact {w : ι' → S.X₃} (hv : ⊤ ≤ span R (range v))
    (hw : ⊤ ≤ span R (range w)) (hE : Epi S.g) :
    ⊤ ≤ span R (range (Sum.elim (S.f ∘ v) (S.g.toFun.invFun ∘ w))) 
Arguments: {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} [Ring R] {S : CategoryTheory.ShortComplex (ModuleCat R)} (hS : S.Exact) {v : ι → ↑S.X₁} {w : ι' → ↑S.X₃} (hv : ⊤ ≤ Submodule.span R (Set.range v)) (hw : ⊤ ≤ Submodule.span R (Set.range w)) (hE : CategoryTheory.Epi S.g)
Goal: ⊤ ≤ Submodule.span R (Set.range (Sum.elim (⇑S.f ∘ v) (Function.invFun S.g.toFun ∘ w)))
-- ModuleCat.free_shortExact
theorem free_shortExact [Module.Free R S.X₁] [Module.Free R S.X₃] :
    Module.Free R S.X₂ 
Arguments: {R : Type u_3} [Ring R] {S : CategoryTheory.ShortComplex (ModuleCat R)} (hS' : S.ShortExact) [Module.Free R ↑S.X₁] [Module.Free R ↑S.X₃]
Goal: Module.Free R ↑S.X₂
-- ModuleCat.free_shortExact_rank_add
theorem free_shortExact_rank_add [Module.Free R S.X₁] [Module.Free R S.X₃]
    [StrongRankCondition R] :
    Module.rank R S.X₂ = Module.rank R S.X₁ + Module.rank R S.X₃ 
Arguments: {R : Type u_3} [Ring R] {S : CategoryTheory.ShortComplex (ModuleCat R)} (hS' : S.ShortExact) [Module.Free R ↑S.X₁] [Module.Free R ↑S.X₃] [StrongRankCondition R]
Goal: Module.rank R ↑S.X₂ = Module.rank R ↑S.X₁ + Module.rank R ↑S.X₃
-- ModuleCat.free_shortExact_finrank_add
theorem free_shortExact_finrank_add {n p : ℕ} [Module.Free R S.X₁] [Module.Free R S.X₃]
    [Module.Finite R S.X₁] [Module.Finite R S.X₃]
    (hN : FiniteDimensional.finrank R S.X₁ = n)
    (hP : FiniteDimensional.finrank R S.X₃ = p)
    [StrongRankCondition R] :
    FiniteDimensional.finrank R S.X₂ = n + p 
Arguments: {R : Type u_3} [Ring R] {S : CategoryTheory.ShortComplex (ModuleCat R)} (hS' : S.ShortExact) {n p : ℕ} [Module.Free R ↑S.X₁] [Module.Free R ↑S.X₃] [Module.Finite R ↑S.X₁] [Module.Finite R ↑S.X₃] (hN : FiniteDimensional.finrank R ↑S.X₁ = n) (hP : FiniteDimensional.finrank R ↑S.X₃ = p) [StrongRankCondition R]
Goal: FiniteDimensional.finrank R ↑S.X₂ = n + p
-- Module.Baer.of_divisible
theorem Module.Baer.of_divisible [DivisibleBy A ℤ] : Module.Baer ℤ A 
Arguments: (A : Type u) [AddCommGroup A] [DivisibleBy A ℤ]
Goal: Module.Baer ℤ A
-- AddCommGrp.injective_as_module_iff
theorem injective_as_module_iff : Injective (⟨A⟩ : ModuleCat ℤ) ↔
    Injective (⟨A,inferInstance⟩ : AddCommGrp) 
Arguments: (A : Type u) [AddCommGroup A]
Goal: CategoryTheory.Injective (ModuleCat.mk A) ↔ CategoryTheory.Injective { α := A, str := inferInstance }
-- GrpWithZero.coe_id
lemma coe_id {X : GrpWithZero} : (𝟙 X : X → X) = id 
Arguments: {X : GrpWithZero}
Goal: ⇑(𝟙 X) = id
-- GrpWithZero.coe_comp
lemma coe_comp {X Y Z : GrpWithZero} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
Arguments: {X Y Z : GrpWithZero} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f
-- GrpWithZero.forget_map
@[simp] lemma forget_map {X Y : GrpWithZero} (f : X ⟶ Y) :
  (forget GrpWithZero).map f = f 
Arguments: {X Y : GrpWithZero} (f : X ⟶ Y)
Goal: (CategoryTheory.forget GrpWithZero).map f = ⇑f
-- GrpWithZero.Iso.mk_inv
@[simps]
def Iso.mk {α β : GrpWithZero.{u}} (e : α ≃* β) : α ≅ β 
Arguments: {α β : GrpWithZero} (e : ↑α ≃* ↑β)
Goal: (GrpWithZero.Iso.mk e).inv = ↑e.symm
-- GrpWithZero.Iso.mk_hom
@[simps]
def Iso.mk {α β : GrpWithZero.{u}} (e : α ≃* β) : α ≅ β 
Arguments: {α β : GrpWithZero} (e : ↑α ≃* ↑β)
Goal: (GrpWithZero.Iso.mk e).hom = ↑e
-- Grp.FilteredColimits.G.mk_eq
@[to_additive]
theorem G.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) :
    G.mk.{v, u} F x = G.mk F y 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.IsFiltered J] (F : J ⥤ Grp) (x y : (j : J) × ↑(F.obj j)) (h : ∃ k f g, (F.map f) x.snd = (F.map g) y.snd)
Goal: Grp.FilteredColimits.G.mk F x = Grp.FilteredColimits.G.mk F y
-- AddGrp.FilteredColimits.G.mk_eq
@[to_additive]
theorem G.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) :
    G.mk.{v, u} F x = G.mk F y 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.IsFiltered J] (F : J ⥤ AddGrp) (x y : (j : J) × ↑(F.obj j)) (h : ∃ k f g, (F.map f) x.snd = (F.map g) y.snd)
Goal: AddGrp.FilteredColimits.G.mk F x = AddGrp.FilteredColimits.G.mk F y
-- Grp.FilteredColimits.colimitInvAux_eq_of_rel
@[to_additive]
theorem colimitInvAux_eq_of_rel (x y : Σ j, F.obj j)
    (h : Types.FilteredColimit.Rel (F ⋙ forget Grp) x y) :
    colimitInvAux.{v, u} F x = colimitInvAux F y 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.IsFiltered J] (F : J ⥤ Grp) (x y : (j : J) × ↑(F.obj j)) (h : CategoryTheory.Limits.Types.FilteredColimit.Rel (F ⋙ CategoryTheory.forget Grp) x y)
Goal: Grp.FilteredColimits.colimitInvAux F x = Grp.FilteredColimits.colimitInvAux F y
-- AddGrp.FilteredColimits.colimitNegAux_eq_of_rel
@[to_additive]
theorem colimitInvAux_eq_of_rel (x y : Σ j, F.obj j)
    (h : Types.FilteredColimit.Rel (F ⋙ forget Grp) x y) :
    colimitInvAux.{v, u} F x = colimitInvAux F y 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.IsFiltered J] (F : J ⥤ AddGrp) (x y : (j : J) × ↑(F.obj j)) (h : CategoryTheory.Limits.Types.FilteredColimit.Rel (F ⋙ CategoryTheory.forget AddGrp) x y)
Goal: AddGrp.FilteredColimits.colimitNegAux F x = AddGrp.FilteredColimits.colimitNegAux F y
-- Grp.FilteredColimits.colimit_inv_mk_eq
@[to_additive (attr := simp)]
theorem colimit_inv_mk_eq (x : Σ j, F.obj j) : (G.mk.{v, u} F x)⁻¹ = G.mk F ⟨x.1, x.2⁻¹⟩ 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.IsFiltered J] (F : J ⥤ Grp) (x : (j : J) × ↑(F.obj j))
Goal: (Grp.FilteredColimits.G.mk F x)⁻¹ = Grp.FilteredColimits.G.mk F ⟨x.fst, x.snd⁻¹⟩
-- AddGrp.FilteredColimits.colimit_neg_mk_eq
@[to_additive (attr := simp)]
theorem colimit_inv_mk_eq (x : Σ j, F.obj j) : (G.mk.{v, u} F x)⁻¹ = G.mk F ⟨x.1, x.2⁻¹⟩ 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.IsFiltered J] (F : J ⥤ AddGrp) (x : (j : J) × ↑(F.obj j))
Goal: -AddGrp.FilteredColimits.G.mk F x = AddGrp.FilteredColimits.G.mk F ⟨x.fst, -x.snd⟩
-- AddCommGrp.image.fac
theorem image.fac : factorThruImage f ≫ image.ι f = f 
Arguments: {G H : AddCommGrp} (f : G ⟶ H)
Goal: AddCommGrp.factorThruImage f ≫ AddCommGrp.image.ι f = f
-- AddCommGrp.image.lift_fac
theorem image.lift_fac (F' : MonoFactorisation f) : image.lift F' ≫ F'.m = image.ι f 
Arguments: {G H : AddCommGrp} {f : G ⟶ H} (F' : CategoryTheory.Limits.MonoFactorisation f)
Goal: AddCommGrp.image.lift F' ≫ F'.m = AddCommGrp.image.ι f
-- ModuleCat.ihom_map_apply
theorem ihom_map_apply {M N P : ModuleCat.{u} R} (f : N ⟶ P) (g : ModuleCat.of R (M ⟶ N)) :
    (ihom M).map f g = g ≫ f 
Arguments: {R : Type u} [CommRing R] {M N P : ModuleCat R} (f : N ⟶ P) (g : ↑(ModuleCat.of R (M ⟶ N)))
Goal: ((CategoryTheory.ihom M).map f) g = g ≫ f
-- ModuleCat.monoidalClosed_curry
theorem monoidalClosed_curry {M N P : ModuleCat.{u} R} (f : M ⊗ N ⟶ P) (x : M) (y : N) :
    @DFunLike.coe _ _ _ LinearMap.instFunLike
      ((MonoidalClosed.curry f : N →ₗ[R] M →ₗ[R] P) y) x = f (x ⊗ₜ[R] y) 
Arguments: {R : Type u} [CommRing R] {M N P : ModuleCat R} (f : CategoryTheory.MonoidalCategory.tensorObj M N ⟶ P) (x : ↑M) (y : ↑N)
Goal: ((CategoryTheory.MonoidalClosed.curry f) y) x = f (x ⊗ₜ[R] y)
-- ModuleCat.monoidalClosed_uncurry
@[simp]
theorem monoidalClosed_uncurry
    {M N P : ModuleCat.{u} R} (f : N ⟶ M ⟶[ModuleCat.{u} R] P) (x : M) (y : N) :
    MonoidalClosed.uncurry f (x ⊗ₜ[R] y) =
      @DFunLike.coe _ _ _ LinearMap.instFunLike (f y) x 
Arguments: {R : Type u} [CommRing R] {M N P : ModuleCat R} (f : N ⟶ (CategoryTheory.ihom M).obj P) (x : ↑M) (y : ↑N)
Goal: (CategoryTheory.MonoidalClosed.uncurry f) (x ⊗ₜ[R] y) = (f y) x
-- ModuleCat.ihom_ev_app
theorem ihom_ev_app (M N : ModuleCat.{u} R) :
    (ihom.ev M).app N = TensorProduct.uncurry _ _ _ _ LinearMap.id.flip 
Arguments: {R : Type u} [CommRing R] (M N : ModuleCat R)
Goal: (CategoryTheory.ihom.ev M).app N = (TensorProduct.uncurry R (↑M) (↑M →ₗ[R] ↑N) ↑N) LinearMap.id.flip
-- ModuleCat.ihom_coev_app
theorem ihom_coev_app (M N : ModuleCat.{u} R) :
    (ihom.coev M).app N = (TensorProduct.mk _ _ _).flip 
Arguments: {R : Type u} [CommRing R] (M N : ModuleCat R)
Goal: (CategoryTheory.ihom.coev M).app N =
  (TensorProduct.mk R ↑(Opposite.unop (Opposite.op M)) ↑((𝟭 (ModuleCat R)).obj N)).flip
-- ModuleCat.monoidalClosed_pre_app
theorem monoidalClosed_pre_app {M N : ModuleCat.{u} R} (P : ModuleCat.{u} R) (f : N ⟶ M) :
    (MonoidalClosed.pre f).app P = LinearMap.lcomp R _ f 
Arguments: {R : Type u} [CommRing R] {M N : ModuleCat R} (P : ModuleCat R) (f : N ⟶ M)
Goal: (CategoryTheory.MonoidalClosed.pre f).app P = LinearMap.lcomp R (↑P) f
-- NeZero.out
class NeZero (n : R) : Prop where
    out : n ≠ 0
Arguments: {R : Type u_1} [Zero R] {n : R} [self : NeZero n]
Goal: n ≠ 0
-- NeZero.ne
theorem NeZero.ne (n : R) [h : NeZero n] : n ≠ 0 
Arguments: {R : Type u_1} [Zero R] (n : R) [h : NeZero n]
Goal: n ≠ 0
-- NeZero.ne'
theorem NeZero.ne' (n : R) [h : NeZero n] : 0 ≠ n 
Arguments: {R : Type u_1} [Zero R] (n : R) [h : NeZero n]
Goal: 0 ≠ n
-- neZero_iff
theorem neZero_iff {n : R} : NeZero n ↔ n ≠ 0 
Arguments: {R : Type u_1} [Zero R] {n : R}
Goal: NeZero n ↔ n ≠ 0
-- neZero_zero_iff_false
@[simp] lemma neZero_zero_iff_false {α : Type*} [Zero α] : NeZero (0 : α) ↔ False 
Arguments: {α : Type u_2} [Zero α]
Goal: NeZero 0 ↔ False
-- not_neZero
theorem not_neZero {n : R} : ¬NeZero n ↔ n = 0 
Arguments: {R : Type u_1} [Zero R] {n : R}
Goal: ¬NeZero n ↔ n = 0
-- eq_zero_or_neZero
theorem eq_zero_or_neZero (a : R) : a = 0 ∨ NeZero a 
Arguments: {R : Type u_1} [Zero R] (a : R)
Goal: a = 0 ∨ NeZero a
-- zero_ne_one
@[simp] lemma zero_ne_one [One α] [NeZero (1 : α)] : (0 : α) ≠ 1 
Arguments: {α : Type u_2} [Zero α] [One α] [NeZero 1]
Goal: 0 ≠ 1
-- one_ne_zero
@[simp] lemma one_ne_zero [One α] [NeZero (1 : α)] : (1 : α) ≠ 0 
Arguments: {α : Type u_2} [Zero α] [One α] [NeZero 1]
Goal: 1 ≠ 0
-- ne_zero_of_eq_one
lemma ne_zero_of_eq_one [One α] [NeZero (1 : α)] {a : α} (h : a = 1) : a ≠ 0 
Arguments: {α : Type u_2} [Zero α] [One α] [NeZero 1] {a : α} (h : a = 1)
Goal: a ≠ 0
-- two_ne_zero
@[field_simps]
lemma two_ne_zero [OfNat α 2] [NeZero (2 : α)] : (2 : α) ≠ 0 
Arguments: {α : Type u_2} [Zero α] [OfNat α 2] [NeZero 2]
Goal: 2 ≠ 0
-- three_ne_zero
@[field_simps]
lemma three_ne_zero [OfNat α 3] [NeZero (3 : α)] : (3 : α) ≠ 0 
Arguments: {α : Type u_2} [Zero α] [OfNat α 3] [NeZero 3]
Goal: 3 ≠ 0
-- four_ne_zero
@[field_simps]
lemma four_ne_zero [OfNat α 4] [NeZero (4 : α)] : (4 : α) ≠ 0 
Arguments: {α : Type u_2} [Zero α] [OfNat α 4] [NeZero 4]
Goal: 4 ≠ 0
-- zero_ne_one'
lemma zero_ne_one' [One α] [NeZero (1 : α)] : (0 : α) ≠ 1 
Arguments: (α : Type u_2) [Zero α] [One α] [NeZero 1]
Goal: 0 ≠ 1
-- one_ne_zero'
lemma one_ne_zero' [One α] [NeZero (1 : α)] : (1 : α) ≠ 0 
Arguments: (α : Type u_2) [Zero α] [One α] [NeZero 1]
Goal: 1 ≠ 0
-- two_ne_zero'
lemma two_ne_zero' [OfNat α 2] [NeZero (2 : α)] : (2 : α) ≠ 0 
Arguments: (α : Type u_2) [Zero α] [OfNat α 2] [NeZero 2]
Goal: 2 ≠ 0
-- three_ne_zero'
lemma three_ne_zero' [OfNat α 3] [NeZero (3 : α)] : (3 : α) ≠ 0 
Arguments: (α : Type u_2) [Zero α] [OfNat α 3] [NeZero 3]
Goal: 3 ≠ 0
-- four_ne_zero'
lemma four_ne_zero' [OfNat α 4] [NeZero (4 : α)] : (4 : α) ≠ 0 
Arguments: (α : Type u_2) [Zero α] [OfNat α 4] [NeZero 4]
Goal: 4 ≠ 0
-- NeZero.of_pos
theorem of_pos [Preorder M] [Zero M] (h : 0 < x) : NeZero x 
Arguments: {M : Type u_2} {x : M} [Preorder M] [Zero M] (h : 0 < x)
Goal: NeZero x
-- Nat.pos_of_neZero
lemma Nat.pos_of_neZero (n : ℕ) [NeZero n] : 0 < n 
Arguments: (n : ℕ) [NeZero n]
Goal: 0 < n
-- RingCat.Colimits.quot_zero
@[simp]
theorem quot_zero : Quot.mk Setoid.r zero = (0 : ColimitType F) 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ RingCat)
Goal: Quot.mk Setoid.r RingCat.Colimits.Prequotient.zero = 0
-- RingCat.Colimits.quot_one
@[simp]
theorem quot_one : Quot.mk Setoid.r one = (1 : ColimitType F) 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ RingCat)
Goal: Quot.mk Setoid.r RingCat.Colimits.Prequotient.one = 1
-- RingCat.Colimits.quot_neg
@[simp]
theorem quot_neg (x : Prequotient F) :
    -- Porting note: Lean can't see `Quot.mk Setoid.r x` is a `ColimitType F` even with type
    -- annotation unless we use `by exact` to change the elaboration order.
    (by exact Quot.mk Setoid.r (neg x) : ColimitType F) = -(by exact Quot.mk Setoid.r x) 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ RingCat) (x : RingCat.Colimits.Prequotient F)
Goal: Quot.mk Setoid.r x.neg = -Quot.mk Setoid.r x
-- RingCat.Colimits.quot_add
@[simp]
theorem quot_add (x y) :
    (by exact Quot.mk Setoid.r (add x y) : ColimitType F) =
      (by exact Quot.mk _ x) + (by exact Quot.mk _ y) 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ RingCat) (x y : RingCat.Colimits.Prequotient F)
Goal: Quot.mk Setoid.r (x.add y) = Quot.mk Setoid.r x + Quot.mk Setoid.r y
-- RingCat.Colimits.quot_mul
@[simp]
theorem quot_mul (x y) :
    (by exact Quot.mk Setoid.r (mul x y) : ColimitType F) =
      (by exact Quot.mk _ x) * (by exact Quot.mk _ y) 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ RingCat) (x y : RingCat.Colimits.Prequotient F)
Goal: Quot.mk Setoid.r (x.mul y) = Quot.mk Setoid.r x * Quot.mk Setoid.r y
-- RingCat.Colimits.cocone_naturality
@[simp]
theorem cocone_naturality {j j' : J} (f : j ⟶ j') :
    F.map f ≫ coconeMorphism F j' = coconeMorphism F j 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ RingCat) {j j' : J} (f : j ⟶ j')
Goal: F.map f ≫ RingCat.Colimits.coconeMorphism F j' = RingCat.Colimits.coconeMorphism F j
-- RingCat.Colimits.cocone_naturality_components
@[simp]
theorem cocone_naturality_components (j j' : J) (f : j ⟶ j') (x : F.obj j) :
    (coconeMorphism F j') (F.map f x) = (coconeMorphism F j) x 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ RingCat) (j j' : J) (f : j ⟶ j') (x : ↑(F.obj j))
Goal: (RingCat.Colimits.coconeMorphism F j') ((F.map f) x) = (RingCat.Colimits.coconeMorphism F j) x
-- CommRingCat.Colimits.quot_zero
@[simp]
theorem quot_zero : Quot.mk Setoid.r zero = (0 : ColimitType F) 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ CommRingCat)
Goal: Quot.mk Setoid.r CommRingCat.Colimits.Prequotient.zero = 0
-- CommRingCat.Colimits.quot_one
@[simp]
theorem quot_one : Quot.mk Setoid.r one = (1 : ColimitType F) 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ CommRingCat)
Goal: Quot.mk Setoid.r CommRingCat.Colimits.Prequotient.one = 1
-- CommRingCat.Colimits.quot_neg
@[simp]
theorem quot_neg (x : Prequotient F) :
    -- Porting note: Lean can't see `Quot.mk Setoid.r x` is a `ColimitType F` even with type
    -- annotation unless we use `by exact` to change the elaboration order.
    (by exact Quot.mk Setoid.r (neg x) : ColimitType F) = -(by exact Quot.mk Setoid.r x) 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ CommRingCat) (x : CommRingCat.Colimits.Prequotient F)
Goal: Quot.mk Setoid.r x.neg = -Quot.mk Setoid.r x
-- CommRingCat.Colimits.quot_add
@[simp]
theorem quot_add (x y) :
    (by exact Quot.mk Setoid.r (add x y) : ColimitType F) =
      (by exact Quot.mk _ x) + (by exact Quot.mk _ y) 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ CommRingCat) (x y : CommRingCat.Colimits.Prequotient F)
Goal: Quot.mk Setoid.r (x.add y) = Quot.mk Setoid.r x + Quot.mk Setoid.r y
-- CommRingCat.Colimits.quot_mul
@[simp]
theorem quot_mul (x y) :
    (by exact Quot.mk Setoid.r (mul x y) : ColimitType F) =
      (by exact Quot.mk _ x) * (by exact Quot.mk _ y) 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ CommRingCat) (x y : CommRingCat.Colimits.Prequotient F)
Goal: Quot.mk Setoid.r (x.mul y) = Quot.mk Setoid.r x * Quot.mk Setoid.r y
-- CommRingCat.Colimits.cocone_naturality
@[simp]
theorem cocone_naturality {j j' : J} (f : j ⟶ j') :
    F.map f ≫ coconeMorphism F j' = coconeMorphism F j 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ CommRingCat) {j j' : J} (f : j ⟶ j')
Goal: F.map f ≫ CommRingCat.Colimits.coconeMorphism F j' = CommRingCat.Colimits.coconeMorphism F j
-- CommRingCat.Colimits.cocone_naturality_components
@[simp]
theorem cocone_naturality_components (j j' : J) (f : j ⟶ j') (x : F.obj j) :
    (coconeMorphism F j') (F.map f x) = (coconeMorphism F j) x 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ CommRingCat) (j j' : J) (f : j ⟶ j') (x : ↑(F.obj j))
Goal: (CommRingCat.Colimits.coconeMorphism F j') ((F.map f) x) = (CommRingCat.Colimits.coconeMorphism F j) x
-- AddCommGrp.Colimits.quot_zero
@[simp]
theorem quot_zero : Quot.mk Setoid.r zero = (0 : ColimitType.{w} F) 
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] (F : J ⥤ AddCommGrp)
Goal: Quot.mk Setoid.r AddCommGrp.Colimits.Prequotient.zero = 0
-- AddCommGrp.Colimits.quot_neg
@[simp]
theorem quot_neg (x) :
    -- Porting note: force Lean to treat `ColimitType F` no as `Quot _`
    (by exact Quot.mk Setoid.r (neg x) : ColimitType.{w} F) =
      -(by exact Quot.mk Setoid.r x) 
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] (F : J ⥤ AddCommGrp) (x : AddCommGrp.Colimits.Prequotient F)
Goal: Quot.mk Setoid.r x.neg = -Quot.mk Setoid.r x
-- AddCommGrp.Colimits.quot_add
@[simp]
theorem quot_add (x y) :
    (by exact Quot.mk Setoid.r (add x y) : ColimitType.{w} F) =
      -- Porting note: force Lean to treat `ColimitType F` no as `Quot _`
      (by exact Quot.mk Setoid.r x) + (by exact Quot.mk Setoid.r y) 
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] (F : J ⥤ AddCommGrp) (x y : AddCommGrp.Colimits.Prequotient F)
Goal: Quot.mk Setoid.r (x.add y) = Quot.mk Setoid.r x + Quot.mk Setoid.r y
-- AddCommGrp.Colimits.cocone_naturality
@[simp]
theorem cocone_naturality {j j' : J} (f : j ⟶ j') :
    F.map f ≫ coconeMorphism.{w} F j' = coconeMorphism F j 
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] (F : J ⥤ AddCommGrp) {j j' : J} (f : j ⟶ j')
Goal: F.map f ≫ AddCommGrp.Colimits.coconeMorphism F j' = AddCommGrp.Colimits.coconeMorphism F j
-- AddCommGrp.Colimits.cocone_naturality_components
@[simp]
theorem cocone_naturality_components (j j' : J) (f : j ⟶ j') (x : F.obj j) :
    (coconeMorphism.{w} F j') (F.map f x) = (coconeMorphism F j) x 
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] (F : J ⥤ AddCommGrp) (j j' : J) (f : j ⟶ j') (x : ↑(F.obj j))
Goal: (AddCommGrp.Colimits.coconeMorphism F j') ((F.map f) x) = (AddCommGrp.Colimits.coconeMorphism F j) x
-- AddCommGrp.hasColimit
lemma hasColimit : HasColimit F 
Arguments: {J : Type u} [CategoryTheory.Category.{v, u} J] (F : J ⥤ AddCommGrp)
Goal: CategoryTheory.Limits.HasColimit F
-- AddCommGrp.hasColimitsOfShape
lemma hasColimitsOfShape : HasColimitsOfShape J AddCommGrp.{max u v w} 
Arguments: (J : Type u) [CategoryTheory.Category.{v, u} J]
Goal: CategoryTheory.Limits.HasColimitsOfShape J AddCommGrp
-- AddCommGrp.hasColimitsOfSize
lemma hasColimitsOfSize : HasColimitsOfSize.{v, u} AddCommGrp.{max u v w} 
Goal: CategoryTheory.Limits.HasColimitsOfSize.{v, u, max (max u v) w, max (max (u + 1) (v + 1)) (w + 1)} AddCommGrp
-- AddCommGrp.free_obj_coe
@[simp]
theorem free_obj_coe {α : Type u} : (free.obj α : Type u) = FreeAbelianGroup α 
Arguments: {α : Type u}
Goal: ↑(AddCommGrp.free.obj α) = FreeAbelianGroup α
-- AddCommGrp.free_map_coe
theorem free_map_coe {α β : Type u} {f : α → β} (x : FreeAbelianGroup α) :
    (free.map f) x = f <$> x 
Arguments: {α β : Type u} {f : α → β} (x : FreeAbelianGroup α)
Goal: (AddCommGrp.free.map f) x = f <$> x
-- MonCat.units_map
@[simps]
def MonCat.units : MonCat.{u} ⥤ Grp.{u} 
Goal: ∀ {X Y : MonCat} (f : X ⟶ Y), MonCat.units.map f = Grp.ofHom (Units.map f)
-- MonCat.units_obj
@[simps]
def MonCat.units : MonCat.{u} ⥤ Grp.{u} 
Arguments: (R : MonCat)
Goal: MonCat.units.obj R = Grp.of (↑R)ˣ
-- CommMonCat.units_map
@[simps]
def CommMonCat.units : CommMonCat.{u} ⥤ CommGrp.{u} 
Goal: ∀ {X Y : CommMonCat} (f : X ⟶ Y), CommMonCat.units.map f = CommGrp.ofHom (Units.map f)
-- CommMonCat.units_obj
@[simps]
def CommMonCat.units : CommMonCat.{u} ⥤ CommGrp.{u} 
Arguments: (R : CommMonCat)
Goal: CommMonCat.units.obj R = CommGrp.of (↑R)ˣ
-- PUnit.zero_eq
@[to_additive (attr := simp, nolint simpNF)]
theorem one_eq : (1 : PUnit) = unit 
Goal: 0 = PUnit.unit
-- PUnit.one_eq
@[to_additive (attr := simp, nolint simpNF)]
theorem one_eq : (1 : PUnit) = unit 
Goal: 1 = PUnit.unit
-- PUnit.mul_eq
@[to_additive]
theorem mul_eq {x y : PUnit} : x * y = unit 
Arguments: {x y : PUnit.{1}}
Goal: x * y = PUnit.unit
-- PUnit.add_eq
@[to_additive]
theorem mul_eq {x y : PUnit} : x * y = unit 
Arguments: {x y : PUnit.{1}}
Goal: x + y = PUnit.unit
-- PUnit.sub_eq
@[to_additive (attr := simp)]
theorem div_eq {x y : PUnit} : x / y = unit 
Arguments: {x y : PUnit.{1}}
Goal: x - y = PUnit.unit
-- PUnit.div_eq
@[to_additive (attr := simp)]
theorem div_eq {x y : PUnit} : x / y = unit 
Arguments: {x y : PUnit.{1}}
Goal: x / y = PUnit.unit
-- PUnit.inv_eq
@[to_additive (attr := simp)]
theorem inv_eq {x : PUnit} : x⁻¹ = unit 
Arguments: {x : PUnit.{1}}
Goal: x⁻¹ = PUnit.unit
-- PUnit.neg_eq
@[to_additive (attr := simp)]
theorem inv_eq {x : PUnit} : x⁻¹ = unit 
Arguments: {x : PUnit.{1}}
Goal: -x = PUnit.unit
-- PUnit.gcd_eq
theorem gcd_eq {x y : PUnit} : gcd x y = unit 
Arguments: {x y : PUnit.{u_1 + 1}}
Goal: gcd x y = PUnit.unit
-- PUnit.lcm_eq
theorem lcm_eq {x y : PUnit} : lcm x y = unit 
Arguments: {x y : PUnit.{u_1 + 1}}
Goal: lcm x y = PUnit.unit
-- PUnit.norm_unit_eq
@[simp]
theorem norm_unit_eq {x : PUnit} : normUnit x = 1 
Arguments: {x : PUnit.{u_1 + 1}}
Goal: normUnit x = 1
-- PUnit.vadd_eq
@[to_additive (attr := simp)]
theorem smul_eq {R : Type*} (y : PUnit) (r : R) : r • y = unit 
Arguments: {R : Type u_3} (y : PUnit.{u_4 + 1}) (r : R)
Goal: r +ᵥ y = PUnit.unit
-- PUnit.smul_eq
@[to_additive (attr := simp)]
theorem smul_eq {R : Type*} (y : PUnit) (r : R) : r • y = unit 
Arguments: {R : Type u_3} (y : PUnit.{u_4 + 1}) (r : R)
Goal: r • y = PUnit.unit
-- GradedMonoid.mk_smul_mk
theorem mk_smul_mk [VAdd ιA ιM] [GSMul A M] {i j} (a : A i) (b : M j) :
    mk i a • mk j b = mk (i +ᵥ j) (GSMul.smul a b) 
Arguments: {ιA : Type u_1} {ιM : Type u_3} (A : ιA → Type u_4) (M : ιM → Type u_5) [VAdd ιA ιM] [GradedMonoid.GSMul A M] {i : ιA} {j : ιM} (a : A i) (b : M j)
Goal: GradedMonoid.mk i a • GradedMonoid.mk j b = GradedMonoid.mk (i +ᵥ j) (GradedMonoid.GSMul.smul a b)
-- GradedMonoid.GMulAction.mul_smul
class GMulAction [AddMonoid ιA] [VAdd ιA ιM] [GMonoid A] extends GSMul A M where
    one_smul (b : GradedMonoid M) : (1 : GradedMonoid A) • b = b
    mul_smul (a a' : GradedMonoid A) (b : GradedMonoid M) : (a * a') • b = a • a' • b
Arguments: {ιA : Type u_1} {ιM : Type u_3} {A : ιA → Type u_4} {M : ιM → Type u_5} [AddMonoid ιA] [VAdd ιA ιM] [GradedMonoid.GMonoid A] [self : GradedMonoid.GMulAction A M] (a a' : GradedMonoid A) (b : GradedMonoid M)
Goal: (a * a') • b = a • a' • b
-- GradedMonoid.GMulAction.one_smul
class GMulAction [AddMonoid ιA] [VAdd ιA ιM] [GMonoid A] extends GSMul A M where
    one_smul (b : GradedMonoid M) : (1 : GradedMonoid A) • b = b
    mul_smul (a a' : GradedMonoid A) (b : GradedMonoid M) : (a * a') • b = a • a' • b
Arguments: {ιA : Type u_1} {ιM : Type u_3} {A : ιA → Type u_4} {M : ιM → Type u_5} [AddMonoid ιA] [VAdd ιA ιM] [GradedMonoid.GMonoid A] [self : GradedMonoid.GMulAction A M] (b : GradedMonoid M)
Goal: 1 • b = b
-- SetLike.GradedSMul.smul_mem
class SetLike.GradedSMul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [VAdd ιA ιB]
  (A : ιA → S) (B : ιB → N) : Prop where
    smul_mem : ∀ ⦃i : ιA⦄ ⦃j : ιB⦄ {ai bj}, ai ∈ A i → bj ∈ B j → ai • bj ∈ B (i +ᵥ j)
Arguments: {ιA : Type u_1} {ιB : Type u_2} {S : Type u_5} {R : Type u_6} {N : Type u_7} {M : Type u_8} [SetLike S R] [SetLike N M] [SMul R M] [VAdd ιA ιB] {A : ιA → S} {B : ιB → N} [self : SetLike.GradedSMul A B] ⦃i : ιA⦄ ⦃j : ιB⦄ {ai : R} {bj : M}
Goal: ai ∈ A i → bj ∈ B j → ai • bj ∈ B (i +ᵥ j)