ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- MvPolynomial.aeval_zero'
@[simp]
theorem aeval_zero' (p : MvPolynomial σ R) :
    aeval (fun _ => 0 : σ → S₁) p = algebraMap _ _ (constantCoeff p) 
Arguments: {R : Type u} {S₁ : Type v} {σ : Type u_1} [CommSemiring R] [CommSemiring S₁] [Algebra R S₁] (p : MvPolynomial σ R)
Goal: (MvPolynomial.aeval fun x => 0) p = (algebraMap R S₁) (MvPolynomial.constantCoeff p)
-- MvPolynomial.eval_zero
@[simp]
theorem eval_zero : eval (0 : σ → R) = constantCoeff 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R]
Goal: MvPolynomial.eval 0 = MvPolynomial.constantCoeff
-- MvPolynomial.eval_zero'
@[simp]
theorem eval_zero' : eval (fun _ => 0 : σ → R) = constantCoeff 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R]
Goal: (MvPolynomial.eval fun x => 0) = MvPolynomial.constantCoeff
-- MvPolynomial.aeval_monomial
theorem aeval_monomial (g : σ → S₁) (d : σ →₀ ℕ) (r : R) :
    aeval g (monomial d r) = algebraMap _ _ r * d.prod fun i k => g i ^ k 
Arguments: {R : Type u} {S₁ : Type v} {σ : Type u_1} [CommSemiring R] [CommSemiring S₁] [Algebra R S₁] (g : σ → S₁) (d : σ →₀ ℕ) (r : R)
Goal: (MvPolynomial.aeval g) ((MvPolynomial.monomial d) r) = (algebraMap R S₁) r * d.prod fun i k => g i ^ k
-- MvPolynomial.eval₂Hom_eq_zero
theorem eval₂Hom_eq_zero (f : R →+* S₂) (g : σ → S₂) (φ : MvPolynomial σ R)
    (h : ∀ d, φ.coeff d ≠ 0 → ∃ i ∈ d.support, g i = 0) : eval₂Hom f g φ = 0 
Arguments: {R : Type u} {S₂ : Type w} {σ : Type u_1} [CommSemiring R] [CommSemiring S₂] (f : R →+* S₂) (g : σ → S₂) (φ : MvPolynomial σ R) (h : ∀ (d : σ →₀ ℕ), MvPolynomial.coeff d φ ≠ 0 → ∃ i ∈ d.support, g i = 0)
Goal: (MvPolynomial.eval₂Hom f g) φ = 0
-- MvPolynomial.aeval_eq_zero
theorem aeval_eq_zero [Algebra R S₂] (f : σ → S₂) (φ : MvPolynomial σ R)
    (h : ∀ d, φ.coeff d ≠ 0 → ∃ i ∈ d.support, f i = 0) : aeval f φ = 0 
Arguments: {R : Type u} {S₂ : Type w} {σ : Type u_1} [CommSemiring R] [CommSemiring S₂] [Algebra R S₂] (f : σ → S₂) (φ : MvPolynomial σ R) (h : ∀ (d : σ →₀ ℕ), MvPolynomial.coeff d φ ≠ 0 → ∃ i ∈ d.support, f i = 0)
Goal: (MvPolynomial.aeval f) φ = 0
-- MvPolynomial.aeval_sum
theorem aeval_sum {ι : Type*} (s : Finset ι) (φ : ι → MvPolynomial σ R) :
    aeval f (∑ i ∈ s, φ i) = ∑ i ∈ s, aeval f (φ i) 
Arguments: {R : Type u} {S₁ : Type v} {σ : Type u_1} [CommSemiring R] [CommSemiring S₁] [Algebra R S₁] (f : σ → S₁) {ι : Type u_2} (s : Finset ι) (φ : ι → MvPolynomial σ R)
Goal: (MvPolynomial.aeval f) (∑ i ∈ s, φ i) = ∑ i ∈ s, (MvPolynomial.aeval f) (φ i)
-- MvPolynomial.aeval_prod
@[to_additive existing]
theorem aeval_prod {ι : Type*} (s : Finset ι) (φ : ι → MvPolynomial σ R) :
    aeval f (∏ i ∈ s, φ i) = ∏ i ∈ s, aeval f (φ i) 
Arguments: {R : Type u} {S₁ : Type v} {σ : Type u_1} [CommSemiring R] [CommSemiring S₁] [Algebra R S₁] (f : σ → S₁) {ι : Type u_2} (s : Finset ι) (φ : ι → MvPolynomial σ R)
Goal: (MvPolynomial.aeval f) (∏ i ∈ s, φ i) = ∏ i ∈ s, (MvPolynomial.aeval f) (φ i)
-- Algebra.adjoin_range_eq_range_aeval
theorem _root_.Algebra.adjoin_range_eq_range_aeval :
    Algebra.adjoin R (Set.range f) = (MvPolynomial.aeval f).range 
Arguments: (R : Type u) {S₁ : Type v} {σ : Type u_1} [CommSemiring R] [CommSemiring S₁] [Algebra R S₁] (f : σ → S₁)
Goal: Algebra.adjoin R (Set.range f) = (MvPolynomial.aeval f).range
-- Algebra.adjoin_eq_range
theorem _root_.Algebra.adjoin_eq_range (s : Set S₁) :
    Algebra.adjoin R s = (MvPolynomial.aeval ((↑) : s → S₁)).range 
Arguments: (R : Type u) {S₁ : Type v} [CommSemiring R] [CommSemiring S₁] [Algebra R S₁] (s : Set S₁)
Goal: Algebra.adjoin R s = (MvPolynomial.aeval Subtype.val).range
-- MvPolynomial.aevalTower_X
@[simp]
theorem aevalTower_X (i : σ) : aevalTower g y (X i) = y i 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {S : Type u_2} {A : Type u_3} [CommSemiring S] [CommSemiring A] [Algebra S R] [Algebra S A] (g : R →ₐ[S] A) (y : σ → A) (i : σ)
Goal: (MvPolynomial.aevalTower g y) (MvPolynomial.X i) = y i
-- MvPolynomial.aevalTower_C
@[simp]
theorem aevalTower_C (x : R) : aevalTower g y (C x) = g x 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {S : Type u_2} {A : Type u_3} [CommSemiring S] [CommSemiring A] [Algebra S R] [Algebra S A] (g : R →ₐ[S] A) (y : σ → A) (x : R)
Goal: (MvPolynomial.aevalTower g y) (MvPolynomial.C x) = g x
-- MvPolynomial.aevalTower_comp_C
@[simp]
theorem aevalTower_comp_C : (aevalTower g y : MvPolynomial σ R →+* A).comp C = g 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {S : Type u_2} {A : Type u_3} [CommSemiring S] [CommSemiring A] [Algebra S R] [Algebra S A] (g : R →ₐ[S] A) (y : σ → A)
Goal: (↑(MvPolynomial.aevalTower g y)).comp MvPolynomial.C = ↑g
-- MvPolynomial.aevalTower_algebraMap
theorem aevalTower_algebraMap (x : R) : aevalTower g y (algebraMap R (MvPolynomial σ R) x) = g x 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {S : Type u_2} {A : Type u_3} [CommSemiring S] [CommSemiring A] [Algebra S R] [Algebra S A] (g : R →ₐ[S] A) (y : σ → A) (x : R)
Goal: (MvPolynomial.aevalTower g y) ((algebraMap R (MvPolynomial σ R)) x) = g x
-- MvPolynomial.aevalTower_comp_algebraMap
theorem aevalTower_comp_algebraMap :
    (aevalTower g y : MvPolynomial σ R →+* A).comp (algebraMap R (MvPolynomial σ R)) = g 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {S : Type u_2} {A : Type u_3} [CommSemiring S] [CommSemiring A] [Algebra S R] [Algebra S A] (g : R →ₐ[S] A) (y : σ → A)
Goal: (↑(MvPolynomial.aevalTower g y)).comp (algebraMap R (MvPolynomial σ R)) = ↑g
-- MvPolynomial.aevalTower_toAlgHom
theorem aevalTower_toAlgHom (x : R) :
    aevalTower g y (IsScalarTower.toAlgHom S R (MvPolynomial σ R) x) = g x 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {S : Type u_2} {A : Type u_3} [CommSemiring S] [CommSemiring A] [Algebra S R] [Algebra S A] (g : R →ₐ[S] A) (y : σ → A) (x : R)
Goal: (MvPolynomial.aevalTower g y) ((IsScalarTower.toAlgHom S R (MvPolynomial σ R)) x) = g x
-- MvPolynomial.aevalTower_comp_toAlgHom
@[simp]
theorem aevalTower_comp_toAlgHom :
    (aevalTower g y).comp (IsScalarTower.toAlgHom S R (MvPolynomial σ R)) = g 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {S : Type u_2} {A : Type u_3} [CommSemiring S] [CommSemiring A] [Algebra S R] [Algebra S A] (g : R →ₐ[S] A) (y : σ → A)
Goal: (MvPolynomial.aevalTower g y).comp (IsScalarTower.toAlgHom S R (MvPolynomial σ R)) = g
-- MvPolynomial.aevalTower_id
@[simp]
theorem aevalTower_id :
    aevalTower (AlgHom.id S S) = (aeval : (σ → S) → MvPolynomial σ S →ₐ[S] S) 
Arguments: {σ : Type u_1} {S : Type u_2} [CommSemiring S]
Goal: MvPolynomial.aevalTower (AlgHom.id S S) = MvPolynomial.aeval
-- MvPolynomial.aevalTower_ofId
@[simp]
theorem aevalTower_ofId :
    aevalTower (Algebra.ofId S A) = (aeval : (σ → A) → MvPolynomial σ S →ₐ[S] A) 
Arguments: {σ : Type u_1} {S : Type u_2} {A : Type u_3} [CommSemiring S] [CommSemiring A] [Algebra S A]
Goal: MvPolynomial.aevalTower (Algebra.ofId S A) = MvPolynomial.aeval
-- MvPolynomial.eval₂_mem
theorem eval₂_mem {f : R →+* S} {p : MvPolynomial σ R} {s : subS}
    (hs : ∀ i ∈ p.support, f (p.coeff i) ∈ s) {v : σ → S} (hv : ∀ i, v i ∈ s) :
    MvPolynomial.eval₂ f v p ∈ s 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {S : Type u_2} {subS : Type u_3} [CommSemiring S] [SetLike subS S] [SubsemiringClass subS S] {f : R →+* S} {p : MvPolynomial σ R} {s : subS} (hs : ∀ i ∈ p.support, f (MvPolynomial.coeff i p) ∈ s) {v : σ → S} (hv : ∀ (i : σ), v i ∈ s)
Goal: MvPolynomial.eval₂ f v p ∈ s
-- MvPolynomial.eval_mem
theorem eval_mem {p : MvPolynomial σ S} {s : subS} (hs : ∀ i ∈ p.support, p.coeff i ∈ s) {v : σ → S}
    (hv : ∀ i, v i ∈ s) : MvPolynomial.eval v p ∈ s 
Arguments: {σ : Type u_1} {S : Type u_2} {subS : Type u_3} [CommSemiring S] [SetLike subS S] [SubsemiringClass subS S] {p : MvPolynomial σ S} {s : subS} (hs : ∀ i ∈ p.support, MvPolynomial.coeff i p ∈ s) {v : σ → S} (hv : ∀ (i : σ), v i ∈ s)
Goal: (MvPolynomial.eval v) p ∈ s
-- ModuleCat.piIsoPi_inv_kernel_ι
@[simp, elementwise]
theorem piIsoPi_inv_kernel_ι (i : ι) :
    (piIsoPi Z).inv ≫ Pi.π Z i = (LinearMap.proj i : (∀ i : ι, Z i) →ₗ[R] Z i) 
Arguments: {R : Type u} [Ring R] {ι : Type v} (Z : ι → ModuleCatMax R) [CategoryTheory.Limits.HasProduct Z] (i : ι)
Goal: (ModuleCat.piIsoPi Z).inv ≫ CategoryTheory.Limits.Pi.π Z i = LinearMap.proj i
-- ModuleCat.piIsoPi_hom_ker_subtype
@[simp, elementwise]
theorem piIsoPi_hom_ker_subtype (i : ι) :
    (piIsoPi Z).hom ≫ (LinearMap.proj i : (∀ i : ι, Z i) →ₗ[R] Z i) = Pi.π Z i 
Arguments: {R : Type u} [Ring R] {ι : Type v} (Z : ι → ModuleCatMax R) [CategoryTheory.Limits.HasProduct Z] (i : ι)
Goal: (ModuleCat.piIsoPi Z).hom ≫ LinearMap.proj i = CategoryTheory.Limits.Pi.π Z i
-- ModuleCat.binaryProductLimitCone_isLimit_lift
@[simps cone_pt isLimit_lift]
def binaryProductLimitCone (M N : ModuleCat.{v} R) : Limits.LimitCone (pair M N) 
Arguments: {R : Type u} [Ring R] (M N : ModuleCat R) (s : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair M N))
Goal: (M.binaryProductLimitCone N).isLimit.lift s =
  LinearMap.prod (s.π.app { as := CategoryTheory.Limits.WalkingPair.left })
    (s.π.app { as := CategoryTheory.Limits.WalkingPair.right })
-- ModuleCat.binaryProductLimitCone_cone_pt
@[simps cone_pt isLimit_lift]
def binaryProductLimitCone (M N : ModuleCat.{v} R) : Limits.LimitCone (pair M N) 
Arguments: {R : Type u} [Ring R] (M N : ModuleCat R)
Goal: (M.binaryProductLimitCone N).cone.pt = ModuleCat.of R (↑M × ↑N)
-- ModuleCat.binaryProductLimitCone_cone_π_app_left
@[simp]
theorem binaryProductLimitCone_cone_π_app_left (M N : ModuleCat.{v} R) :
    (binaryProductLimitCone M N).cone.π.app ⟨WalkingPair.left⟩ = LinearMap.fst R M N 
Arguments: {R : Type u} [Ring R] (M N : ModuleCat R)
Goal: (M.binaryProductLimitCone N).cone.π.app { as := CategoryTheory.Limits.WalkingPair.left } = LinearMap.fst R ↑M ↑N
-- ModuleCat.binaryProductLimitCone_cone_π_app_right
@[simp]
theorem binaryProductLimitCone_cone_π_app_right (M N : ModuleCat.{v} R) :
    (binaryProductLimitCone M N).cone.π.app ⟨WalkingPair.right⟩ = LinearMap.snd R M N 
Arguments: {R : Type u} [Ring R] (M N : ModuleCat R)
Goal: (M.binaryProductLimitCone N).cone.π.app { as := CategoryTheory.Limits.WalkingPair.right } = LinearMap.snd R ↑M ↑N
-- ModuleCat.biprodIsoProd_hom_apply
@[simps! hom_apply]
noncomputable def biprodIsoProd (M N : ModuleCat.{v} R) :
    (M ⊞ N : ModuleCat.{v} R) ≅ ModuleCat.of R (M × N) 
Arguments: {R : Type u} [Ring R] (M N : ModuleCat R) (i : ↑(CategoryTheory.Limits.BinaryBiproduct.bicone M N).toCone.pt)
Goal: (M.biprodIsoProd N).hom i = (CategoryTheory.Limits.biprod.fst i, CategoryTheory.Limits.biprod.snd i)
-- ModuleCat.biprodIsoProd_inv_comp_fst
@[simp, elementwise]
theorem biprodIsoProd_inv_comp_fst (M N : ModuleCat.{v} R) :
    (biprodIsoProd M N).inv ≫ biprod.fst = LinearMap.fst R M N 
Arguments: {R : Type u} [Ring R] (M N : ModuleCat R)
Goal: (M.biprodIsoProd N).inv ≫ CategoryTheory.Limits.biprod.fst = LinearMap.fst R ↑M ↑N
-- ModuleCat.biprodIsoProd_inv_comp_snd
@[simp, elementwise]
theorem biprodIsoProd_inv_comp_snd (M N : ModuleCat.{v} R) :
    (biprodIsoProd M N).inv ≫ biprod.snd = LinearMap.snd R M N 
Arguments: {R : Type u} [Ring R] (M N : ModuleCat R)
Goal: (M.biprodIsoProd N).inv ≫ CategoryTheory.Limits.biprod.snd = LinearMap.snd R ↑M ↑N
-- ModuleCat.HasLimit.lift_apply
@[simps]
def lift (s : Fan f) : s.pt ⟶ ModuleCat.of R (∀ j, f j) 
Arguments: {R : Type u} [Ring R] {J : Type w} (f : J → ModuleCat R) (s : CategoryTheory.Limits.Fan f) (x : ↑s.pt) (j : J)
Goal: (ModuleCat.HasLimit.lift f s) x j = (s.π.app { as := j }) x
-- ModuleCat.HasLimit.productLimitCone_cone_pt
@[simps]
def productLimitCone : Limits.LimitCone (Discrete.functor f) 
Arguments: {R : Type u} [Ring R] {J : Type w} (f : J → ModuleCat R)
Goal: (ModuleCat.HasLimit.productLimitCone f).cone.pt = ModuleCat.of R ((j : J) → ↑(f j))
-- ModuleCat.HasLimit.productLimitCone_cone_π
@[simps]
def productLimitCone : Limits.LimitCone (Discrete.functor f) 
Arguments: {R : Type u} [Ring R] {J : Type w} (f : J → ModuleCat R)
Goal: (ModuleCat.HasLimit.productLimitCone f).cone.π = CategoryTheory.Discrete.natTrans fun j => LinearMap.proj j.as
-- ModuleCat.HasLimit.productLimitCone_isLimit_lift
@[simps]
def productLimitCone : Limits.LimitCone (Discrete.functor f) 
Arguments: {R : Type u} [Ring R] {J : Type w} (f : J → ModuleCat R) (s : CategoryTheory.Limits.Fan f)
Goal: (ModuleCat.HasLimit.productLimitCone f).isLimit.lift s = ModuleCat.HasLimit.lift f s
-- ModuleCat.biproductIsoPi_hom_apply
@[simps! hom_apply]
noncomputable def biproductIsoPi [Finite J] (f : J → ModuleCat.{v} R) :
    ((⨁ f) : ModuleCat.{v} R) ≅ ModuleCat.of R (∀ j, f j) 
Arguments: {R : Type u} [Ring R] {J : Type} [Finite J] (f : J → ModuleCat R) (x : ↑(CategoryTheory.Limits.biproduct.bicone f).toCone.pt) (j : J)
Goal: (ModuleCat.biproductIsoPi f).hom x j = (CategoryTheory.Limits.biproduct.π f j) x
-- ModuleCat.biproductIsoPi_inv_comp_π
@[simp, elementwise]
theorem biproductIsoPi_inv_comp_π [Finite J] (f : J → ModuleCat.{v} R) (j : J) :
    (biproductIsoPi f).inv ≫ biproduct.π f j = (LinearMap.proj j : (∀ j, f j) →ₗ[R] f j) 
Arguments: {R : Type u} [Ring R] {J : Type} [Finite J] (f : J → ModuleCat R) (j : J)
Goal: (ModuleCat.biproductIsoPi f).inv ≫ CategoryTheory.Limits.biproduct.π f j = LinearMap.proj j
-- ModuleCat.enoughInjectives
lemma ModuleCat.enoughInjectives : EnoughInjectives (ModuleCat.{max v u} R) 
Arguments: (R : Type u) [Ring R]
Goal: CategoryTheory.EnoughInjectives (ModuleCat R)
-- AddMonCat.FilteredColimits.M.mk_eq
@[to_additive]
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.{v, u} F x = M.mk F y 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ AddMonCatMax) (x y : (j : J) × ↑(F.obj j)) (h : ∃ k f g, (F.map f) x.snd = (F.map g) y.snd)
Goal: AddMonCat.FilteredColimits.M.mk F x = AddMonCat.FilteredColimits.M.mk F y
-- MonCat.FilteredColimits.M.mk_eq
@[to_additive]
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.{v, u} F x = M.mk F y 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ MonCatMax) (x y : (j : J) × ↑(F.obj j)) (h : ∃ k f g, (F.map f) x.snd = (F.map g) y.snd)
Goal: MonCat.FilteredColimits.M.mk F x = MonCat.FilteredColimits.M.mk F y
-- MonCat.FilteredColimits.colimit_one_eq
@[to_additive
      "The definition of the \"zero\" in the colimit is independent of the chosen object
      of `J`. In particular, this lemma allows us to \"unfold\" the definition of `colimit_zero` at
      a custom chosen object `j`."]
theorem colimit_one_eq (j : J) : (1 : M.{v, u} F) = M.mk F ⟨j, 1⟩ 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ MonCatMax) [CategoryTheory.IsFiltered J] (j : J)
Goal: 1 = MonCat.FilteredColimits.M.mk F ⟨j, 1⟩
-- AddMonCat.FilteredColimits.colimit_zero_eq
@[to_additive
      "The definition of the \"zero\" in the colimit is independent of the chosen object
      of `J`. In particular, this lemma allows us to \"unfold\" the definition of `colimit_zero` at
      a custom chosen object `j`."]
theorem colimit_one_eq (j : J) : (1 : M.{v, u} F) = M.mk F ⟨j, 1⟩ 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ AddMonCatMax) [CategoryTheory.IsFiltered J] (j : J)
Goal: 0 = AddMonCat.FilteredColimits.M.mk F ⟨j, 0⟩
-- MonCat.FilteredColimits.colimitMulAux_eq_of_rel_left
@[to_additive "Addition in the colimit is well-defined in the left argument."]
theorem colimitMulAux_eq_of_rel_left {x x' y : Σ j, F.obj j}
    (hxx' : Types.FilteredColimit.Rel (F ⋙ forget MonCat) x x') :
    colimitMulAux.{v, u} F x y = colimitMulAux.{v, u} F x' y 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ MonCatMax) [CategoryTheory.IsFiltered J] {x x' y : (j : J) × ↑(F.obj j)} (hxx' : CategoryTheory.Limits.Types.FilteredColimit.Rel (F ⋙ CategoryTheory.forget MonCat) x x')
Goal: MonCat.FilteredColimits.colimitMulAux F x y = MonCat.FilteredColimits.colimitMulAux F x' y
-- AddMonCat.FilteredColimits.colimitAddAux_eq_of_rel_left
@[to_additive "Addition in the colimit is well-defined in the left argument."]
theorem colimitMulAux_eq_of_rel_left {x x' y : Σ j, F.obj j}
    (hxx' : Types.FilteredColimit.Rel (F ⋙ forget MonCat) x x') :
    colimitMulAux.{v, u} F x y = colimitMulAux.{v, u} F x' y 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ AddMonCatMax) [CategoryTheory.IsFiltered J] {x x' y : (j : J) × ↑(F.obj j)} (hxx' : CategoryTheory.Limits.Types.FilteredColimit.Rel (F ⋙ CategoryTheory.forget AddMonCat) x x')
Goal: AddMonCat.FilteredColimits.colimitAddAux F x y = AddMonCat.FilteredColimits.colimitAddAux F x' y
-- MonCat.FilteredColimits.colimitMulAux_eq_of_rel_right
@[to_additive "Addition in the colimit is well-defined in the right argument."]
theorem colimitMulAux_eq_of_rel_right {x y y' : Σ j, F.obj j}
    (hyy' : Types.FilteredColimit.Rel (F ⋙ forget MonCat) y y') :
    colimitMulAux.{v, u} F x y = colimitMulAux.{v, u} F x y' 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ MonCatMax) [CategoryTheory.IsFiltered J] {x y y' : (j : J) × ↑(F.obj j)} (hyy' : CategoryTheory.Limits.Types.FilteredColimit.Rel (F ⋙ CategoryTheory.forget MonCat) y y')
Goal: MonCat.FilteredColimits.colimitMulAux F x y = MonCat.FilteredColimits.colimitMulAux F x y'
-- AddMonCat.FilteredColimits.colimitAddAux_eq_of_rel_right
@[to_additive "Addition in the colimit is well-defined in the right argument."]
theorem colimitMulAux_eq_of_rel_right {x y y' : Σ j, F.obj j}
    (hyy' : Types.FilteredColimit.Rel (F ⋙ forget MonCat) y y') :
    colimitMulAux.{v, u} F x y = colimitMulAux.{v, u} F x y' 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ AddMonCatMax) [CategoryTheory.IsFiltered J] {x y y' : (j : J) × ↑(F.obj j)} (hyy' : CategoryTheory.Limits.Types.FilteredColimit.Rel (F ⋙ CategoryTheory.forget AddMonCat) y y')
Goal: AddMonCat.FilteredColimits.colimitAddAux F x y = AddMonCat.FilteredColimits.colimitAddAux F x y'
-- AddMonCat.FilteredColimits.colimit_add_mk_eq
@[to_additive
      "Addition in the colimit is independent of the chosen \"maximum\" in the filtered
      category. In particular, this lemma allows us to \"unfold\" the definition of the addition of
      `x` and `y`, using a custom object `k` and morphisms `f : x.1 ⟶ k` and `g : y.1 ⟶ k`."]
theorem colimit_mul_mk_eq (x y : Σ j, F.obj j) (k : J) (f : x.1 ⟶ k) (g : y.1 ⟶ k) :
    M.mk.{v, u} F x * M.mk F y = M.mk F ⟨k, F.map f x.2 * F.map g y.2⟩ 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ AddMonCatMax) [CategoryTheory.IsFiltered J] (x y : (j : J) × ↑(F.obj j)) (k : J) (f : x.fst ⟶ k) (g : y.fst ⟶ k)
Goal: AddMonCat.FilteredColimits.M.mk F x + AddMonCat.FilteredColimits.M.mk F y =
  AddMonCat.FilteredColimits.M.mk F ⟨k, (F.map f) x.snd + (F.map g) y.snd⟩
-- MonCat.FilteredColimits.colimit_mul_mk_eq
@[to_additive
      "Addition in the colimit is independent of the chosen \"maximum\" in the filtered
      category. In particular, this lemma allows us to \"unfold\" the definition of the addition of
      `x` and `y`, using a custom object `k` and morphisms `f : x.1 ⟶ k` and `g : y.1 ⟶ k`."]
theorem colimit_mul_mk_eq (x y : Σ j, F.obj j) (k : J) (f : x.1 ⟶ k) (g : y.1 ⟶ k) :
    M.mk.{v, u} F x * M.mk F y = M.mk F ⟨k, F.map f x.2 * F.map g y.2⟩ 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ MonCatMax) [CategoryTheory.IsFiltered J] (x y : (j : J) × ↑(F.obj j)) (k : J) (f : x.fst ⟶ k) (g : y.fst ⟶ k)
Goal: MonCat.FilteredColimits.M.mk F x * MonCat.FilteredColimits.M.mk F y =
  MonCat.FilteredColimits.M.mk F ⟨k, (F.map f) x.snd * (F.map g) y.snd⟩
-- AddMonCat.FilteredColimits.cocone_naturality
@[to_additive (attr := simp)]
theorem cocone_naturality {j j' : J} (f : j ⟶ j') :
    F.map f ≫ coconeMorphism.{v, u} F j' = coconeMorphism F j 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ AddMonCatMax) [CategoryTheory.IsFiltered J] {j j' : J} (f : j ⟶ j')
Goal: F.map f ≫ AddMonCat.FilteredColimits.coconeMorphism F j' = AddMonCat.FilteredColimits.coconeMorphism F j
-- MonCat.FilteredColimits.cocone_naturality
@[to_additive (attr := simp)]
theorem cocone_naturality {j j' : J} (f : j ⟶ j') :
    F.map f ≫ coconeMorphism.{v, u} F j' = coconeMorphism F j 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] (F : J ⥤ MonCatMax) [CategoryTheory.IsFiltered J] {j j' : J} (f : j ⟶ j')
Goal: F.map f ≫ MonCat.FilteredColimits.coconeMorphism F j' = MonCat.FilteredColimits.coconeMorphism F j
-- ModuleCat.toKernelSubobject_arrow
@[simp]
theorem toKernelSubobject_arrow {M N : ModuleCat R} {f : M ⟶ N} (x : LinearMap.ker f) :
    (kernelSubobject f).arrow (toKernelSubobject x) = x.1 
Arguments: {R : Type u} [Ring R] {M N : ModuleCat R} {f : M ⟶ N} (x : ↥(LinearMap.ker f))
Goal: (CategoryTheory.Limits.kernelSubobject f).arrow (ModuleCat.toKernelSubobject x) = ↑x
-- ModuleCat.cokernel_π_imageSubobject_ext
-- Porting note (#11215): TODO compiler complains that this is marked with `@[ext]`.
-- Should this be changed?
-- @[ext] this is no longer an ext lemma under the current interpretation see eg
-- the conversation beginning at
-- https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/
-- Goal.20state.20not.20updating.2C.20bugs.2C.20etc.2E/near/338456803
theorem cokernel_π_imageSubobject_ext {L M N : ModuleCat.{v} R} (f : L ⟶ M) [HasImage f]
    (g : (imageSubobject f : ModuleCat.{v} R) ⟶ N) [HasCokernel g] {x y : N} (l : L)
    (w : x = y + g (factorThruImageSubobject f l)) : cokernel.π g x = cokernel.π g y 
Arguments: {R : Type u} [Ring R] {L M N : ModuleCat R} (f : L ⟶ M) [CategoryTheory.Limits.HasImage f] (g : CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.imageSubobject f) ⟶ N) [CategoryTheory.Limits.HasCokernel g] {x y : ↑N} (l : ↑L) (w : x = y + g ((CategoryTheory.Limits.factorThruImageSubobject f) l))
Goal: (CategoryTheory.Limits.cokernel.π g) x = (CategoryTheory.Limits.cokernel.π g) y
-- SheafOfModules.isSheaf
structure SheafOfModules where
    val : PresheafOfModules.{v} R.val
  isSheaf : Presheaf.IsSheaf J val.presheaf
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {R : CategoryTheory.Sheaf J RingCat} (self : SheafOfModules R)
Goal: CategoryTheory.Presheaf.IsSheaf J self.val.presheaf
-- SheafOfModules.hom_ext
@[ext]
lemma hom_ext {X Y : SheafOfModules.{v} R} {f g : X ⟶ Y} (h : f.val = g.val) : f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {R : CategoryTheory.Sheaf J RingCat} {X Y : SheafOfModules R} {f g : X ⟶ Y} (h : f.val = g.val)
Goal: f = g
-- SheafOfModules.id_val
@[simp]
lemma id_val (X : SheafOfModules.{v} R) : Hom.val (𝟙 X) = 𝟙 X.val 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {R : CategoryTheory.Sheaf J RingCat} (X : SheafOfModules R)
Goal: (𝟙 X).val = 𝟙 X.val
-- SheafOfModules.comp_val
@[simp, reassoc]
lemma comp_val {X Y Z : SheafOfModules.{v} R} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).val = f.val ≫ g.val 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {R : CategoryTheory.Sheaf J RingCat} {X Y Z : SheafOfModules R} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: (f ≫ g).val = f.val ≫ g.val
-- SheafOfModules.forget_map
@[simps]
def forget : SheafOfModules.{v} R ⥤ PresheafOfModules R.val 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} (R : CategoryTheory.Sheaf J RingCat)
Goal: ∀ {X Y : SheafOfModules R} (φ : X ⟶ Y), (SheafOfModules.forget R).map φ = φ.val
-- SheafOfModules.forget_obj
@[simps]
def forget : SheafOfModules.{v} R ⥤ PresheafOfModules R.val 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} (R : CategoryTheory.Sheaf J RingCat) (F : SheafOfModules R)
Goal: (SheafOfModules.forget R).obj F = F.val
-- SheafOfModules.fullyFaithfulForget_preimage_val
@[simps]
def fullyFaithfulForget : (forget.{v} R).FullyFaithful 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} (R : CategoryTheory.Sheaf J RingCat)
Goal: ∀ {X Y : SheafOfModules R} (φ : (SheafOfModules.forget R).obj X ⟶ (SheafOfModules.forget R).obj Y),
  ((SheafOfModules.fullyFaithfulForget R).preimage φ).val = φ