ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- SheafOfModules.QuasicoherentData.localGeneratorsData_I
@[simps]
def localGeneratorsData (q : M.QuasicoherentData) : M.LocalGeneratorsData 
Arguments: {C : Type u'} [CategoryTheory.Category.{v', u'} C] {J : CategoryTheory.GrothendieckTopology C} {R : CategoryTheory.Sheaf J RingCat} {M : SheafOfModules R} [∀ (X : C), (J.over X).HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrp)] [∀ (X : C), CategoryTheory.HasWeakSheafify (J.over X) AddCommGrp] [∀ (X : C), (J.over X).WEqualsLocallyBijective AddCommGrp] (q : M.QuasicoherentData)
Goal: q.localGeneratorsData.I = q.I
-- SheafOfModules.QuasicoherentData.localGeneratorsData_X
@[simps]
def localGeneratorsData (q : M.QuasicoherentData) : M.LocalGeneratorsData 
Arguments: {C : Type u'} [CategoryTheory.Category.{v', u'} C] {J : CategoryTheory.GrothendieckTopology C} {R : CategoryTheory.Sheaf J RingCat} {M : SheafOfModules R} [∀ (X : C), (J.over X).HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrp)] [∀ (X : C), CategoryTheory.HasWeakSheafify (J.over X) AddCommGrp] [∀ (X : C), (J.over X).WEqualsLocallyBijective AddCommGrp] (q : M.QuasicoherentData)
Goal: ∀ (a : q.I), q.localGeneratorsData.X a = q.X a
-- SheafOfModules.QuasicoherentData.localGeneratorsData_generators
@[simps]
def localGeneratorsData (q : M.QuasicoherentData) : M.LocalGeneratorsData 
Arguments: {C : Type u'} [CategoryTheory.Category.{v', u'} C] {J : CategoryTheory.GrothendieckTopology C} {R : CategoryTheory.Sheaf J RingCat} {M : SheafOfModules R} [∀ (X : C), (J.over X).HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrp)] [∀ (X : C), CategoryTheory.HasWeakSheafify (J.over X) AddCommGrp] [∀ (X : C), (J.over X).WEqualsLocallyBijective AddCommGrp] (q : M.QuasicoherentData) (i : q.I)
Goal: q.localGeneratorsData.generators i = (q.presentation i).generators
-- SheafOfModules.IsQuasicoherent.nonempty_quasicoherentData
class IsQuasicoherent : Prop where
  nonempty_quasicoherentData : Nonempty M.QuasicoherentData
Arguments: {C : Type u'} [CategoryTheory.Category.{v', u'} C] {J : CategoryTheory.GrothendieckTopology C} {R : CategoryTheory.Sheaf J RingCat} {M : SheafOfModules R} [∀ (X : C), (J.over X).HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrp)] [∀ (X : C), CategoryTheory.HasWeakSheafify (J.over X) AddCommGrp] [∀ (X : C), (J.over X).WEqualsLocallyBijective AddCommGrp] [self : M.IsQuasicoherent]
Goal: Nonempty M.QuasicoherentData
-- SheafOfModules.IsFinitePresentation.exists_quasicoherentData
class IsFinitePresentation : Prop where
  exists_quasicoherentData :
    ∃ (σ : M.QuasicoherentData), ∀ (i : σ.I), (Finite (σ.presentation i).generators.I ∧
      Finite (σ.presentation i).relations.I)
Arguments: {C : Type u'} [CategoryTheory.Category.{v', u'} C] {J : CategoryTheory.GrothendieckTopology C} {R : CategoryTheory.Sheaf J RingCat} {M : SheafOfModules R} [∀ (X : C), (J.over X).HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrp)] [∀ (X : C), CategoryTheory.HasWeakSheafify (J.over X) AddCommGrp] [∀ (X : C), (J.over X).WEqualsLocallyBijective AddCommGrp] [self : M.IsFinitePresentation]
Goal: ∃ σ, ∀ (i : σ.I), Finite (σ.presentation i).generators.I ∧ Finite (σ.presentation i).relations.I
-- ModuleCat.hasLimitsOfShape
lemma hasLimitsOfShape [Small.{w} J] : HasLimitsOfShape J (ModuleCat.{w} R) 
Arguments: {R : Type u} [Ring R] {J : Type v} [CategoryTheory.Category.{t, v} J] [Small.{w, v} J]
Goal: CategoryTheory.Limits.HasLimitsOfShape J (ModuleCat R)
-- ModuleCat.hasLimitsOfSize
lemma hasLimitsOfSize [UnivLE.{v, w}] : HasLimitsOfSize.{t, v} (ModuleCat.{w} R) 
Arguments: {R : Type u} [Ring R] [UnivLE.{v, w}]
Goal: CategoryTheory.Limits.HasLimitsOfSize.{t, v, w, max (w + 1) u} (ModuleCat R)
-- ModuleCat.directLimitDiagram_obj
@[simps]
def directLimitDiagram : ι ⥤ ModuleCat R 
Arguments: {R : Type u} [Ring R] {ι : Type v} [Preorder ι] (G : ι → Type v) [(i : ι) → AddCommGroup (G i)] [(i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j) [DirectedSystem G fun i j h => ⇑(f i j h)] (i : ι)
Goal: (ModuleCat.directLimitDiagram G f).obj i = ModuleCat.of R (G i)
-- ModuleCat.directLimitDiagram_map
@[simps]
def directLimitDiagram : ι ⥤ ModuleCat R 
Arguments: {R : Type u} [Ring R] {ι : Type v} [Preorder ι] (G : ι → Type v) [(i : ι) → AddCommGroup (G i)] [(i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j) [DirectedSystem G fun i j h => ⇑(f i j h)]
Goal: ∀ {X Y : ι} (hij : X ⟶ Y), (ModuleCat.directLimitDiagram G f).map hij = f X Y ⋯
-- ModuleCat.directLimitCocone_pt
@[simps]
def directLimitCocone : Cocone (directLimitDiagram G f) 
Arguments: {R : Type u} [Ring R] {ι : Type v} [Preorder ι] (G : ι → Type v) [(i : ι) → AddCommGroup (G i)] [(i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j) [DirectedSystem G fun i j h => ⇑(f i j h)] [DecidableEq ι]
Goal: (ModuleCat.directLimitCocone G f).pt = ModuleCat.of R (Module.DirectLimit G f)
-- ModuleCat.directLimitCocone_ι_app
@[simps]
def directLimitCocone : Cocone (directLimitDiagram G f) 
Arguments: {R : Type u} [Ring R] {ι : Type v} [Preorder ι] (G : ι → Type v) [(i : ι) → AddCommGroup (G i)] [(i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j) [DirectedSystem G fun i j h => ⇑(f i j h)] [DecidableEq ι] (i : ι)
Goal: (ModuleCat.directLimitCocone G f).ι.app i = Module.DirectLimit.of R ι G f i
-- ModuleCat.directLimitIsColimit_desc
@[simps]
def directLimitIsColimit [IsDirected ι (· ≤ ·)] : IsColimit (directLimitCocone G f) 
Arguments: {R : Type u} [Ring R] {ι : Type v} [Preorder ι] (G : ι → Type v) [(i : ι) → AddCommGroup (G i)] [(i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j) [DirectedSystem G fun i j h => ⇑(f i j h)] [DecidableEq ι] [IsDirected ι fun x x_1 => x ≤ x_1] (s : CategoryTheory.Limits.Cocone (ModuleCat.directLimitDiagram G f))
Goal: (ModuleCat.directLimitIsColimit G f).desc s = Module.DirectLimit.lift R ι G f s.ι.app ⋯
-- PresheafOfModules.isSheaf_of_isLimit
lemma isSheaf_of_isLimit : Presheaf.IsSheaf J (c.pt.presheaf) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {R : Cᵒᵖ ⥤ RingCat} {F : D ⥤ PresheafOfModules R} [∀ (X : Cᵒᵖ),
    Small.{v, max u₂ v}
      ↑((F ⋙ PresheafOfModules.evaluation R X) ⋙ CategoryTheory.forget (ModuleCat ↑(R.obj X))).sections] {c : CategoryTheory.Limits.Cone F} (hc : CategoryTheory.Limits.IsLimit c) (hF : ∀ (j : D), CategoryTheory.Presheaf.IsSheaf J (F.obj j).presheaf) [CategoryTheory.Limits.HasLimitsOfShape D AddCommGrp]
Goal: CategoryTheory.Presheaf.IsSheaf J c.pt.presheaf
-- ModuleCat.ext
@[ext]
lemma ext {M N : ModuleCat.{v} R} {f₁ f₂ : M ⟶ N} (h : ∀ (x : M), f₁ x = f₂ x) : f₁ = f₂ 
Arguments: (R : Type u) [Ring R] {M N : ModuleCat R} {f₁ f₂ : M ⟶ N} (h : ∀ (x : ↑M), f₁ x = f₂ x)
Goal: f₁ = f₂
-- ModuleCat.forget₂_obj
@[simp]
theorem forget₂_obj (X : ModuleCat R) :
    (forget₂ (ModuleCat R) AddCommGrp).obj X = AddCommGrp.of X 
Arguments: (R : Type u) [Ring R] (X : ModuleCat R)
Goal: (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).obj X = AddCommGrp.of ↑X
-- ModuleCat.forget₂_obj_moduleCat_of
theorem forget₂_obj_moduleCat_of (X : Type v) [AddCommGroup X] [Module R X] :
    (forget₂ (ModuleCat R) AddCommGrp).obj (of R X) = AddCommGrp.of X 
Arguments: (R : Type u) [Ring R] (X : Type v) [AddCommGroup X] [Module R X]
Goal: (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).obj (ModuleCat.of R X) = AddCommGrp.of X
-- ModuleCat.forget₂_map
@[simp]
theorem forget₂_map (X Y : ModuleCat R) (f : X ⟶ Y) :
    (forget₂ (ModuleCat R) AddCommGrp).map f = LinearMap.toAddMonoidHom f 
Arguments: (R : Type u) [Ring R] (X Y : ModuleCat R) (f : X ⟶ Y)
Goal: (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).map f = LinearMap.toAddMonoidHom f
-- ModuleCat.ofHom_apply
@[simp 1100]
theorem ofHom_apply {R : Type u} [Ring R] {X Y : Type v} [AddCommGroup X] [Module R X]
    [AddCommGroup Y] [Module R Y] (f : X →ₗ[R] Y) (x : X) : ofHom f x = f x 
Arguments: {R : Type u} [Ring R] {X Y : Type v} [AddCommGroup X] [Module R X] [AddCommGroup Y] [Module R Y] (f : X →ₗ[R] Y) (x : X)
Goal: (ModuleCat.ofHom f) x = f x
-- ModuleCat.of_coe
@[simp] theorem of_coe (X : ModuleCat R) : of R X = X 
Arguments: (R : Type u) [Ring R] (X : ModuleCat R)
Goal: ModuleCat.of R ↑X = X
-- ModuleCat.coe_of
theorem coe_of (X : Type v) [AddCommGroup X] [Module R X] : (of R X : Type v) = X 
Arguments: (R : Type u) [Ring R] (X : Type v) [AddCommGroup X] [Module R X]
Goal: ↑(ModuleCat.of R X) = X
-- ModuleCat.ofSelfIso_hom
@[simps]
def ofSelfIso (M : ModuleCat R) : ModuleCat.of R M ≅ M 
Arguments: {R : Type u} [Ring R] (M : ModuleCat R)
Goal: M.ofSelfIso.hom = 𝟙 M
-- ModuleCat.ofSelfIso_inv
@[simps]
def ofSelfIso (M : ModuleCat R) : ModuleCat.of R M ≅ M 
Arguments: {R : Type u} [Ring R] (M : ModuleCat R)
Goal: M.ofSelfIso.inv = 𝟙 M
-- ModuleCat.isZero_of_subsingleton
theorem isZero_of_subsingleton (M : ModuleCat R) [Subsingleton M] : IsZero M 
Arguments: {R : Type u} [Ring R] (M : ModuleCat R) [Subsingleton ↑M]
Goal: CategoryTheory.Limits.IsZero M
-- ModuleCat.id_apply
@[simp]
theorem id_apply (m : M) : (𝟙 M : M → M) m = m 
Arguments: {R : Type u} [Ring R] {M : ModuleCat R} (m : ↑M)
Goal: (𝟙 M) m = m
-- ModuleCat.coe_comp
@[simp]
theorem coe_comp (f : M ⟶ N) (g : N ⟶ U) : (f ≫ g : M → U) = g ∘ f 
Arguments: {R : Type u} [Ring R] {M N U : ModuleCat R} (f : M ⟶ N) (g : N ⟶ U)
Goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f
-- ModuleCat.comp_def
theorem comp_def (f : M ⟶ N) (g : N ⟶ U) : f ≫ g = g.comp f 
Arguments: {R : Type u} [Ring R] {M N U : ModuleCat R} (f : M ⟶ N) (g : N ⟶ U)
Goal: f ≫ g = g ∘ₗ f
-- ModuleCat.forget_map
@[simp] lemma forget_map (f : M ⟶ N) : (forget (ModuleCat R)).map f = (f : M → N) 
Arguments: {R : Type u} [Ring R] {M N : ModuleCat R} (f : M ⟶ N)
Goal: (CategoryTheory.forget (ModuleCat R)).map f = ⇑f
-- LinearEquiv.toModuleIso_inv
@[simps]
def LinearEquiv.toModuleIso {g₁ : AddCommGroup X₁} {g₂ : AddCommGroup X₂} {m₁ : Module R X₁}
    {m₂ : Module R X₂} (e : X₁ ≃ₗ[R] X₂) : ModuleCat.of R X₁ ≅ ModuleCat.of R X₂ 
Arguments: {R : Type u} [Ring R] {X₁ X₂ : Type v} {g₁ : AddCommGroup X₁} {g₂ : AddCommGroup X₂} {m₁ : Module R X₁} {m₂ : Module R X₂} (e : X₁ ≃ₗ[R] X₂)
Goal: e.toModuleIso.inv = ↑e.symm
-- LinearEquiv.toModuleIso_hom
@[simps]
def LinearEquiv.toModuleIso {g₁ : AddCommGroup X₁} {g₂ : AddCommGroup X₂} {m₁ : Module R X₁}
    {m₂ : Module R X₂} (e : X₁ ≃ₗ[R] X₂) : ModuleCat.of R X₁ ≅ ModuleCat.of R X₂ 
Arguments: {R : Type u} [Ring R] {X₁ X₂ : Type v} {g₁ : AddCommGroup X₁} {g₂ : AddCommGroup X₂} {m₁ : Module R X₁} {m₂ : Module R X₂} (e : X₁ ≃ₗ[R] X₂)
Goal: e.toModuleIso.hom = ↑e
-- linearEquivIsoModuleIso_hom
@[simps]
def linearEquivIsoModuleIso {X Y : Type u} [AddCommGroup X] [AddCommGroup Y] [Module R X]
    [Module R Y] : (X ≃ₗ[R] Y) ≅ ModuleCat.of R X ≅ ModuleCat.of R Y 
Arguments: {R : Type u} [Ring R] {X Y : Type u} [AddCommGroup X] [AddCommGroup Y] [Module R X] [Module R Y] (e : X ≃ₗ[R] Y)
Goal: linearEquivIsoModuleIso.hom e = e.toModuleIso
-- linearEquivIsoModuleIso_inv
@[simps]
def linearEquivIsoModuleIso {X Y : Type u} [AddCommGroup X] [AddCommGroup Y] [Module R X]
    [Module R Y] : (X ≃ₗ[R] Y) ≅ ModuleCat.of R X ≅ ModuleCat.of R Y 
Arguments: {R : Type u} [Ring R] {X Y : Type u} [AddCommGroup X] [AddCommGroup Y] [Module R X] [Module R Y] (i : ModuleCat.of R X ≅ ModuleCat.of R Y)
Goal: linearEquivIsoModuleIso.inv i = i.toLinearEquiv
-- ModuleCat.Iso.homCongr_eq_arrowCongr
theorem Iso.homCongr_eq_arrowCongr (i : X ≅ X') (j : Y ≅ Y') (f : X ⟶ Y) :
    Iso.homCongr i j f = LinearEquiv.arrowCongr i.toLinearEquiv j.toLinearEquiv f 
Arguments: {S : Type u} [CommRing S] {X Y X' Y' : ModuleCat S} (i : X ≅ X') (j : Y ≅ Y') (f : X ⟶ Y)
Goal: (i.homCongr j) f = (i.toLinearEquiv.arrowCongr j.toLinearEquiv) f
-- ModuleCat.Iso.conj_eq_conj
theorem Iso.conj_eq_conj (i : X ≅ X') (f : End X) :
    Iso.conj i f = LinearEquiv.conj i.toLinearEquiv f 
Arguments: {S : Type u} [CommRing S] {X X' : ModuleCat S} (i : X ≅ X') (f : CategoryTheory.End X)
Goal: i.conj f = i.toLinearEquiv.conj f
-- ModuleCat.smul_naturality
lemma smul_naturality {M N : ModuleCat.{v} R} (f : M ⟶ N) (r : R) :
    (forget₂ (ModuleCat R) AddCommGrp).map f ≫ N.smul r =
      M.smul r ≫ (forget₂ (ModuleCat R) AddCommGrp).map f 
Arguments: {R : Type u} [Ring R] {M N : ModuleCat R} (f : M ⟶ N) (r : R)
Goal: (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).map f ≫ N.smul r =
  M.smul r ≫ (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).map f
-- ModuleCat.smulNatTrans_apply_app
@[simps]
def smulNatTrans : R →+* End (forget₂ (ModuleCat R) AddCommGrp) 
Arguments: (R : Type u) [Ring R] (r : R) (M : ModuleCat R)
Goal: ((ModuleCat.smulNatTrans R) r).app M = M.smul r
-- ModuleCat.mkOfSMul'_smul
@[simp]
lemma mkOfSMul'_smul (r : R) (x : mkOfSMul' φ) :
    r • x = (show A ⟶ A from φ r) x 
Arguments: {R : Type u} [Ring R] {A : AddCommGrp} (φ : R →+* CategoryTheory.End A) (r : R) (x : ↑(ModuleCat.mkOfSMul' φ))
Goal: r • x =
  (let_fun this := φ r;
    this)
    x
-- ModuleCat.mkOfSMul_smul
@[simp, nolint simpNF]
lemma mkOfSMul_smul (r : R) : (mkOfSMul φ).smul r = φ r 
Arguments: {R : Type u} [Ring R] {A : AddCommGrp} (φ : R →+* CategoryTheory.End A) (r : R)
Goal: (ModuleCat.mkOfSMul φ).smul r = φ r
-- ModuleCat.homMk_apply
@[simps]
def homMk : M ⟶ N 
Arguments: {R : Type u} [Ring R] {M N : ModuleCat R} (φ : (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).obj M ⟶ (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).obj N) (hφ : ∀ (r : R), φ ≫ N.smul r = M.smul r ≫ φ) (a : ↑((CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).obj M))
Goal: (ModuleCat.homMk φ hφ) a = φ a
-- ModuleCat.forget₂_map_homMk
lemma forget₂_map_homMk :
    (forget₂ (ModuleCat R) AddCommGrp).map (homMk φ hφ) = φ 
Arguments: {R : Type u} [Ring R] {M N : ModuleCat R} (φ : (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).obj M ⟶ (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).obj N) (hφ : ∀ (r : R), φ ≫ N.smul r = M.smul r ≫ φ)
Goal: (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).map (ModuleCat.homMk φ hφ) = φ
-- LinearMap.comp_id_moduleCat
@[simp] theorem LinearMap.comp_id_moduleCat
    {R} [Ring R] {G : ModuleCat.{u} R} {H : Type u} [AddCommGroup H] [Module R H] (f : G →ₗ[R] H) :
    f.comp (𝟙 G) = f 
Arguments: {R : Type u_1} [Ring R] {G : ModuleCat R} {H : Type u} [AddCommGroup H] [Module R H] (f : ↑G →ₗ[R] H)
Goal: f ∘ₗ 𝟙 G = f
-- LinearMap.id_moduleCat_comp
@[simp] theorem LinearMap.id_moduleCat_comp
    {R} [Ring R] {G : Type u} [AddCommGroup G] [Module R G] {H : ModuleCat.{u} R} (f : G →ₗ[R] H) :
    LinearMap.comp (𝟙 H) f = f 
Arguments: {R : Type u_1} [Ring R] {G : Type u} [AddCommGroup G] [Module R G] {H : ModuleCat R} (f : G →ₗ[R] ↑H)
Goal: 𝟙 H ∘ₗ f = f
-- ModuleCat.image.fac
theorem image.fac : factorThruImage f ≫ image.ι f = f 
Arguments: {R : Type u} [Ring R] {G H : ModuleCat R} (f : G ⟶ H)
Goal: ModuleCat.factorThruImage f ≫ ModuleCat.image.ι f = f
-- ModuleCat.image.lift_fac
theorem image.lift_fac (F' : MonoFactorisation f) : image.lift F' ≫ F'.m = image.ι f 
Arguments: {R : Type u} [Ring R] {G H : ModuleCat R} {f : G ⟶ H} (F' : CategoryTheory.Limits.MonoFactorisation f)
Goal: ModuleCat.image.lift F' ≫ F'.m = ModuleCat.image.ι f
-- ModuleCat.imageIsoRange_inv_image_ι
@[simp, reassoc, elementwise]
theorem imageIsoRange_inv_image_ι {G H : ModuleCat.{v} R} (f : G ⟶ H) :
    (imageIsoRange f).inv ≫ Limits.image.ι f = ModuleCat.ofHom f.range.subtype 
Arguments: {R : Type u} [Ring R] {G H : ModuleCat R} (f : G ⟶ H)
Goal: (ModuleCat.imageIsoRange f).inv ≫ CategoryTheory.Limits.image.ι f = ModuleCat.ofHom (LinearMap.range f).subtype
-- ModuleCat.imageIsoRange_hom_subtype
@[simp, reassoc, elementwise]
theorem imageIsoRange_hom_subtype {G H : ModuleCat.{v} R} (f : G ⟶ H) :
    (imageIsoRange f).hom ≫ ModuleCat.ofHom f.range.subtype = Limits.image.ι f 
Arguments: {R : Type u} [Ring R] {G H : ModuleCat R} (f : G ⟶ H)
Goal: (ModuleCat.imageIsoRange f).hom ≫ ModuleCat.ofHom (LinearMap.range f).subtype = CategoryTheory.Limits.image.ι f
-- ModuleCat.HasColimit.coconePointSMul_apply
@[simps]
noncomputable def coconePointSMul :
    R →+* End (colimit (F ⋙ forget₂ _ AddCommGrp)) 
Arguments: {R : Type w} [Ring R] {J : Type u} [CategoryTheory.Category.{v, u} J] (F : J ⥤ ModuleCat R) [CategoryTheory.Limits.HasColimit (F ⋙ CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)] (r : R)
Goal: (ModuleCat.HasColimit.coconePointSMul F) r =
  CategoryTheory.Limits.colimMap { app := fun j => (F.obj j).smul r, naturality := ⋯ }
-- ModuleCat.HasColimit.colimitCocone_pt
@[simps]
noncomputable def colimitCocone : Cocone F 
Arguments: {R : Type w} [Ring R] {J : Type u} [CategoryTheory.Category.{v, u} J] (F : J ⥤ ModuleCat R) [CategoryTheory.Limits.HasColimit (F ⋙ CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)]
Goal: (ModuleCat.HasColimit.colimitCocone F).pt = ModuleCat.mkOfSMul (ModuleCat.HasColimit.coconePointSMul F)
-- ModuleCat.HasColimit.colimitCocone_ι_app
@[simps]
noncomputable def colimitCocone : Cocone F 
Arguments: {R : Type w} [Ring R] {J : Type u} [CategoryTheory.Category.{v, u} J] (F : J ⥤ ModuleCat R) [CategoryTheory.Limits.HasColimit (F ⋙ CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)] (j : J)
Goal: (ModuleCat.HasColimit.colimitCocone F).ι.app j =
  ModuleCat.homMk (CategoryTheory.Limits.colimit.ι (F ⋙ CategoryTheory.forget₂ (ModuleCat R) AddCommGrp) j) ⋯
-- ModuleCat.MonoidalCategory.braiding_naturality
@[simp]
theorem braiding_naturality {X₁ X₂ Y₁ Y₂ : ModuleCat.{u} R} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
    (f ⊗ g) ≫ (Y₁.braiding Y₂).hom = (X₁.braiding X₂).hom ≫ (g ⊗ f) 
Arguments: {R : Type u} [CommRing R] {X₁ X₂ Y₁ Y₂ : ModuleCat R} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂)
Goal: (f ⊗ g) ≫ (Y₁.braiding Y₂).hom = (X₁.braiding X₂).hom ≫ (g ⊗ f)
-- ModuleCat.MonoidalCategory.braiding_naturality_left
@[simp]
theorem braiding_naturality_left {X Y : ModuleCat R} (f : X ⟶ Y) (Z : ModuleCat R) :
    f ▷ Z ≫ (braiding Y Z).hom = (braiding X Z).hom ≫ Z ◁ f 
Arguments: {R : Type u} [CommRing R] {X Y : ModuleCat R} (f : X ⟶ Y) (Z : ModuleCat R)
Goal: f ▷ Z ≫ (Y.braiding Z).hom = (X.braiding Z).hom ≫ Z ◁ f
-- ModuleCat.MonoidalCategory.braiding_naturality_right
@[simp]
theorem braiding_naturality_right (X : ModuleCat R) {Y Z : ModuleCat R} (f : Y ⟶ Z) :
    X ◁ f ≫ (braiding X Z).hom = (braiding X Y).hom ≫ f ▷ X 
Arguments: {R : Type u} [CommRing R] (X : ModuleCat R) {Y Z : ModuleCat R} (f : Y ⟶ Z)
Goal: X ◁ f ≫ (X.braiding Z).hom = (X.braiding Y).hom ≫ f ▷ X
-- ModuleCat.MonoidalCategory.hexagon_forward
@[simp]
theorem hexagon_forward (X Y Z : ModuleCat.{u} R) :
    (α_ X Y Z).hom ≫ (braiding X _).hom ≫ (α_ Y Z X).hom =
      (braiding X Y).hom ▷ Z ≫ (α_ Y X Z).hom ≫ Y ◁ (braiding X Z).hom 
Arguments: {R : Type u} [CommRing R] (X Y Z : ModuleCat R)
Goal: (α_ X Y Z).hom ≫ (X.braiding (Y ⊗ Z)).hom ≫ (α_ Y Z X).hom =
  (X.braiding Y).hom ▷ Z ≫ (α_ Y X Z).hom ≫ Y ◁ (X.braiding Z).hom
-- ModuleCat.MonoidalCategory.hexagon_reverse
@[simp]
theorem hexagon_reverse (X Y Z : ModuleCat.{u} R) :
    (α_ X Y Z).inv ≫ (braiding _ Z).hom ≫ (α_ Z X Y).inv =
      X ◁ (Y.braiding Z).hom ≫ (α_ X Z Y).inv ≫ (X.braiding Z).hom ▷ Y 
Arguments: {R : Type u} [CommRing R] (X Y Z : ModuleCat R)
Goal: (α_ X Y Z).inv ≫ ((X ⊗ Y).braiding Z).hom ≫ (α_ Z X Y).inv =
  X ◁ (Y.braiding Z).hom ≫ (α_ X Z Y).inv ≫ (X.braiding Z).hom ▷ Y
-- ModuleCat.MonoidalCategory.braiding_hom_apply
@[simp]
theorem braiding_hom_apply {M N : ModuleCat.{u} R} (m : M) (n : N) :
    ((β_ M N).hom : M ⊗ N ⟶ N ⊗ M) (m ⊗ₜ n) = n ⊗ₜ m 
Arguments: {R : Type u} [CommRing R] {M N : ModuleCat R} (m : ↑M) (n : ↑N)
Goal: (β_ M N).hom (m ⊗ₜ[R] n) = n ⊗ₜ[R] m
-- ModuleCat.MonoidalCategory.braiding_inv_apply
@[simp]
theorem braiding_inv_apply {M N : ModuleCat.{u} R} (m : M) (n : N) :
    ((β_ M N).inv : N ⊗ M ⟶ M ⊗ N) (n ⊗ₜ m) = m ⊗ₜ n 
Arguments: {R : Type u} [CommRing R] {M N : ModuleCat R} (m : ↑M) (n : ↑N)
Goal: (β_ M N).inv (n ⊗ₜ[R] m) = m ⊗ₜ[R] n
-- ModuleCat.MonoidalCategory.tensor_μ_eq_tensorTensorTensorComm
theorem tensor_μ_eq_tensorTensorTensorComm {A B C D : ModuleCat R} :
    tensor_μ _ (A, B) (C, D) = (TensorProduct.tensorTensorTensorComm R A B C D).toLinearMap 
Arguments: {R : Type u} [CommRing R] {A B C D : ModuleCat R}
Goal: CategoryTheory.tensor_μ (ModuleCat R) (A, B) (C, D) = ↑(TensorProduct.tensorTensorTensorComm R ↑A ↑B ↑C ↑D)
-- ModuleCat.MonoidalCategory.tensor_μ_apply
@[simp]
theorem tensor_μ_apply
    {A B C D : ModuleCat R} (x : A) (y : B) (z : C) (w : D) :
    tensor_μ _ (A, B) (C, D) ((x ⊗ₜ y) ⊗ₜ (z ⊗ₜ w)) = (x ⊗ₜ z) ⊗ₜ (y ⊗ₜ w) 
Arguments: {R : Type u} [CommRing R] {A B C D : ModuleCat R} (x : ↑A) (y : ↑B) (z : ↑C) (w : ↑D)
Goal: (CategoryTheory.tensor_μ (ModuleCat R) (A, B) (C, D)) ((x ⊗ₜ[R] y) ⊗ₜ[R] z ⊗ₜ[R] w) = (x ⊗ₜ[R] z) ⊗ₜ[R] y ⊗ₜ[R] w
-- CommRingCat.free_obj_coe
@[simp]
theorem free_obj_coe {α : Type u} : (free.obj α : Type u) = MvPolynomial α ℤ 
Arguments: {α : Type u}
Goal: ↑(CommRingCat.free.obj α) = MvPolynomial α ℤ
-- CommRingCat.free_map_coe
@[simp, nolint simpNF]
theorem free_map_coe {α β : Type u} {f : α → β} : ⇑(free.map f) = ⇑(rename f) 
Arguments: {α β : Type u} {f : α → β}
Goal: ⇑(CommRingCat.free.map f) = ⇑(MvPolynomial.rename f)
-- IsLocalization.epi
theorem IsLocalization.epi {R : Type*} [CommRing R] (M : Submonoid R) (S : Type _) [CommRing S]
    [Algebra R S] [IsLocalization M S] : Epi (CommRingCat.ofHom <| algebraMap R S) 
Arguments: {R : Type u_1} [CommRing R] (M : Submonoid R) (S : Type u_1) [CommRing S] [Algebra R S] [IsLocalization M S]
Goal: CategoryTheory.Epi (CommRingCat.ofHom (algebraMap R S))
-- isLocalRingHom_of_iso
theorem isLocalRingHom_of_iso {R S : CommRingCat} (f : R ≅ S) : IsLocalRingHom f.hom 
Arguments: {R S : CommRingCat} (f : R ≅ S)
Goal: IsLocalRingHom f.hom
-- AddCommGrp.hom_add_apply
@[simp]
lemma hom_add_apply {P Q : AddCommGrp} (f g : P ⟶ Q) (x : P) : (f + g) x = f x + g x 
Arguments: {P Q : AddCommGrp} (f g : P ⟶ Q) (x : ↑P)
Goal: (f + g) x = f x + g x
-- PresheafOfModules.colimitBundledCore_map
@[simps]
noncomputable def colimitBundledCore : 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 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)] {X Y : Cᵒᵖ} (f : X ⟶ Y)
Goal: (PresheafOfModules.colimitBundledCore F).map f =
  CategoryTheory.Limits.colimMap (CategoryTheory.whiskerLeft F (PresheafOfModules.restriction R f)) ≫
    (CategoryTheory.preservesColimitIso (ModuleCat.restrictScalars (R.map f))
        (F ⋙ PresheafOfModules.evaluation R Y)).inv
-- PresheafOfModules.colimitBundledCore_obj
@[simps]
noncomputable def colimitBundledCore : 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 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)] (X : Cᵒᵖ)
Goal: (PresheafOfModules.colimitBundledCore F).obj X = CategoryTheory.Limits.colimit (F ⋙ PresheafOfModules.evaluation R X)
-- PresheafOfModules.colimitCoconeιApp_naturality
@[reassoc (attr := simp)]
lemma colimitCoconeιApp_naturality {i j : J} (f : i ⟶ j) :
    F.map f ≫ colimitCoconeιApp F j = colimitCoconeιApp F i 
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)] {i j : J} (f : i ⟶ j)
Goal: F.map f ≫ PresheafOfModules.colimitCoconeιApp F j = PresheafOfModules.colimitCoconeιApp F i