ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- IsLocalizedModule.mk'_eq_mk'_iff
theorem mk'_eq_mk'_iff (m₁ m₂ : M) (s₁ s₂ : S) :
    mk' f m₁ s₁ = mk' f m₂ s₂ ↔ ∃ s : S, s • s₁ • m₂ = s • s₂ • m₁ 
Arguments: {R : Type u_1} [CommSemiring R] {S : Submonoid R} {M : Type u_2} {M' : Type u_3} [AddCommMonoid M] [AddCommMonoid M'] [Module R M] [Module R M'] (f : M →ₗ[R] M') [IsLocalizedModule S f] (m₁ m₂ : M) (s₁ s₂ : ↥S)
Goal: IsLocalizedModule.mk' f m₁ s₁ = IsLocalizedModule.mk' f m₂ s₂ ↔ ∃ s, s • s₁ • m₂ = s • s₂ • m₁
-- IsLocalizedModule.mk'_neg
theorem mk'_neg {M M' : Type*} [AddCommGroup M] [AddCommGroup M'] [Module R M] [Module R M']
    (f : M →ₗ[R] M') [IsLocalizedModule S f] (m : M) (s : S) : mk' f (-m) s = -mk' f m s 
Arguments: {R : Type u_1} [CommSemiring R] {S : Submonoid R} {M : Type u_6} {M' : Type u_7} [AddCommGroup M] [AddCommGroup M'] [Module R M] [Module R M'] (f : M →ₗ[R] M') [IsLocalizedModule S f] (m : M) (s : ↥S)
Goal: IsLocalizedModule.mk' f (-m) s = -IsLocalizedModule.mk' f m s
-- IsLocalizedModule.mk'_sub
theorem mk'_sub {M M' : Type*} [AddCommGroup M] [AddCommGroup M'] [Module R M] [Module R M']
    (f : M →ₗ[R] M') [IsLocalizedModule S f] (m₁ m₂ : M) (s : S) :
    mk' f (m₁ - m₂) s = mk' f m₁ s - mk' f m₂ s 
Arguments: {R : Type u_1} [CommSemiring R] {S : Submonoid R} {M : Type u_6} {M' : Type u_7} [AddCommGroup M] [AddCommGroup M'] [Module R M] [Module R M'] (f : M →ₗ[R] M') [IsLocalizedModule S f] (m₁ m₂ : M) (s : ↥S)
Goal: IsLocalizedModule.mk' f (m₁ - m₂) s = IsLocalizedModule.mk' f m₁ s - IsLocalizedModule.mk' f m₂ s
-- IsLocalizedModule.mk'_sub_mk'
theorem mk'_sub_mk' {M M' : Type*} [AddCommGroup M] [AddCommGroup M'] [Module R M] [Module R M']
    (f : M →ₗ[R] M') [IsLocalizedModule S f] (m₁ m₂ : M) (s₁ s₂ : S) :
    mk' f m₁ s₁ - mk' f m₂ s₂ = mk' f (s₂ • m₁ - s₁ • m₂) (s₁ * s₂) 
Arguments: {R : Type u_1} [CommSemiring R] {S : Submonoid R} {M : Type u_6} {M' : Type u_7} [AddCommGroup M] [AddCommGroup M'] [Module R M] [Module R M'] (f : M →ₗ[R] M') [IsLocalizedModule S f] (m₁ m₂ : M) (s₁ s₂ : ↥S)
Goal: IsLocalizedModule.mk' f m₁ s₁ - IsLocalizedModule.mk' f m₂ s₂ = IsLocalizedModule.mk' f (s₂ • m₁ - s₁ • m₂) (s₁ * s₂)
-- IsLocalizedModule.mk'_mul_mk'_of_map_mul
theorem mk'_mul_mk'_of_map_mul {M M' : Type*} [Semiring M] [Semiring M'] [Module R M]
    [Algebra R M'] (f : M →ₗ[R] M') (hf : ∀ m₁ m₂, f (m₁ * m₂) = f m₁ * f m₂)
    [IsLocalizedModule S f] (m₁ m₂ : M) (s₁ s₂ : S) :
    mk' f m₁ s₁ * mk' f m₂ s₂ = mk' f (m₁ * m₂) (s₁ * s₂) 
Arguments: {R : Type u_1} [CommSemiring R] {S : Submonoid R} {M : Type u_6} {M' : Type u_7} [Semiring M] [Semiring M'] [Module R M] [Algebra R M'] (f : M →ₗ[R] M') (hf : ∀ (m₁ m₂ : M), f (m₁ * m₂) = f m₁ * f m₂) [IsLocalizedModule S f] (m₁ m₂ : M) (s₁ s₂ : ↥S)
Goal: IsLocalizedModule.mk' f m₁ s₁ * IsLocalizedModule.mk' f m₂ s₂ = IsLocalizedModule.mk' f (m₁ * m₂) (s₁ * s₂)
-- IsLocalizedModule.mk'_mul_mk'
theorem mk'_mul_mk' {M M' : Type*} [Semiring M] [Semiring M'] [Algebra R M] [Algebra R M']
    (f : M →ₐ[R] M') [IsLocalizedModule S f.toLinearMap] (m₁ m₂ : M) (s₁ s₂ : S) :
    mk' f.toLinearMap m₁ s₁ * mk' f.toLinearMap m₂ s₂ = mk' f.toLinearMap (m₁ * m₂) (s₁ * s₂) 
Arguments: {R : Type u_1} [CommSemiring R] {S : Submonoid R} {M : Type u_6} {M' : Type u_7} [Semiring M] [Semiring M'] [Algebra R M] [Algebra R M'] (f : M →ₐ[R] M') [IsLocalizedModule S f.toLinearMap] (m₁ m₂ : M) (s₁ s₂ : ↥S)
Goal: IsLocalizedModule.mk' f.toLinearMap m₁ s₁ * IsLocalizedModule.mk' f.toLinearMap m₂ s₂ =
  IsLocalizedModule.mk' f.toLinearMap (m₁ * m₂) (s₁ * s₂)
-- IsLocalizedModule.mk'_eq_iff
theorem mk'_eq_iff {m : M} {s : S} {m' : M'} : mk' f m s = m' ↔ f m = s • m' 
Arguments: {R : Type u_1} [CommSemiring R] {S : Submonoid R} {M : Type u_2} {M' : Type u_3} [AddCommMonoid M] [AddCommMonoid M'] [Module R M] [Module R M'] {f : M →ₗ[R] M'} [IsLocalizedModule S f] {m : M} {s : ↥S} {m' : M'}
Goal: IsLocalizedModule.mk' f m s = m' ↔ f m = s • m'
-- IsLocalizedModule.mk'_eq_zero
@[simp]
theorem mk'_eq_zero {m : M} (s : S) : mk' f m s = 0 ↔ f m = 0 
Arguments: {R : Type u_1} [CommSemiring R] {S : Submonoid R} {M : Type u_2} {M' : Type u_3} [AddCommMonoid M] [AddCommMonoid M'] [Module R M] [Module R M'] {f : M →ₗ[R] M'} [IsLocalizedModule S f] {m : M} (s : ↥S)
Goal: IsLocalizedModule.mk' f m s = 0 ↔ f m = 0
-- IsLocalizedModule.mk'_eq_zero'
theorem mk'_eq_zero' {m : M} (s : S) : mk' f m s = 0 ↔ ∃ s' : S, s' • m = 0 
Arguments: {R : Type u_1} [CommSemiring R] {S : Submonoid R} {M : Type u_2} {M' : Type u_3} [AddCommMonoid M] [AddCommMonoid M'] [Module R M] [Module R M'] (f : M →ₗ[R] M') [IsLocalizedModule S f] {m : M} (s : ↥S)
Goal: IsLocalizedModule.mk' f m s = 0 ↔ ∃ s', s' • m = 0
-- IsLocalizedModule.mk_eq_mk'
theorem mk_eq_mk' (s : S) (m : M) :
    LocalizedModule.mk m s = mk' (LocalizedModule.mkLinearMap S M) m s 
Arguments: {R : Type u_1} [CommSemiring R] {S : Submonoid R} {M : Type u_2} [AddCommMonoid M] [Module R M] (s : ↥S) (m : M)
Goal: LocalizedModule.mk m s = IsLocalizedModule.mk' (LocalizedModule.mkLinearMap S M) m s
-- IsLocalizedModule.mk'_smul_mk'
lemma mk'_smul_mk' (x : R) (m : M) (s t : S) :
    IsLocalization.mk' A x s • mk' f m t = mk' f (x • m) (s * t) 
Arguments: {R : Type u_1} [CommSemiring R] {S : Submonoid R} {M : Type u_2} {M' : Type u_3} [AddCommMonoid M] [AddCommMonoid M'] (A : Type u_5) [CommSemiring A] [Algebra R A] [Module A M'] [IsLocalization S A] [Module R M] [Module R M'] [IsScalarTower R A M'] (f : M →ₗ[R] M') [IsLocalizedModule S f] (x : R) (m : M) (s t : ↥S)
Goal: IsLocalization.mk' A x s • IsLocalizedModule.mk' f m t = IsLocalizedModule.mk' f (x • m) (s * t)
-- IsLocalizedModule.eq_zero_iff
theorem eq_zero_iff {m : M} : f m = 0 ↔ ∃ s' : S, s' • m = 0 
Arguments: {R : Type u_1} [CommSemiring R] (S : Submonoid R) {M : Type u_2} {M' : Type u_3} [AddCommMonoid M] [AddCommMonoid M'] [Module R M] [Module R M'] (f : M →ₗ[R] M') [IsLocalizedModule S f] {m : M}
Goal: f m = 0 ↔ ∃ s', s' • m = 0
-- IsLocalizedModule.mk'_surjective
theorem mk'_surjective : Function.Surjective (Function.uncurry <| mk' f : M × S → M') 
Arguments: {R : Type u_1} [CommSemiring R] (S : Submonoid R) {M : Type u_2} {M' : Type u_3} [AddCommMonoid M] [AddCommMonoid M'] [Module R M] [Module R M'] (f : M →ₗ[R] M') [IsLocalizedModule S f]
Goal: Function.Surjective (Function.uncurry (IsLocalizedModule.mk' f))
-- IsLocalizedModule.map_comp
lemma map_comp (h : M →ₗ[R] N) : (map S f g h) ∘ₗ f = g ∘ₗ h 
Arguments: {R : Type u_1} [CommSemiring R] (S : Submonoid R) {M : Type u_2} {M' : Type u_3} [AddCommMonoid M] [AddCommMonoid M'] [Module R M] [Module R M'] (f : M →ₗ[R] M') [IsLocalizedModule S f] {N : Type u_6} {N' : Type u_7} [AddCommGroup N] [AddCommGroup N'] [Module R N] [Module R N'] (g : N →ₗ[R] N') [IsLocalizedModule S g] (h : M →ₗ[R] N)
Goal: (IsLocalizedModule.map S f g) h ∘ₗ f = g ∘ₗ h
-- IsLocalizedModule.map_apply
@[simp]
lemma map_apply (h : M →ₗ[R] N) (x) : map S f g h (f x) = g (h x) 
Arguments: {R : Type u_1} [CommSemiring R] (S : Submonoid R) {M : Type u_2} {M' : Type u_3} [AddCommMonoid M] [AddCommMonoid M'] [Module R M] [Module R M'] (f : M →ₗ[R] M') [IsLocalizedModule S f] {N : Type u_6} {N' : Type u_7} [AddCommGroup N] [AddCommGroup N'] [Module R N] [Module R N'] (g : N →ₗ[R] N') [IsLocalizedModule S g] (h : M →ₗ[R] N) (x : M)
Goal: ((IsLocalizedModule.map S f g) h) (f x) = g (h x)
-- IsLocalizedModule.map_mk'
@[simp]
lemma map_mk' (h : M →ₗ[R] N) (x) (s : S) :
    map S f g h (IsLocalizedModule.mk' f x s) = (IsLocalizedModule.mk' g (h x) s) 
Arguments: {R : Type u_1} [CommSemiring R] (S : Submonoid R) {M : Type u_2} {M' : Type u_3} [AddCommMonoid M] [AddCommMonoid M'] [Module R M] [Module R M'] (f : M →ₗ[R] M') [IsLocalizedModule S f] {N : Type u_6} {N' : Type u_7} [AddCommGroup N] [AddCommGroup N'] [Module R N] [Module R N'] (g : N →ₗ[R] N') [IsLocalizedModule S g] (h : M →ₗ[R] N) (x : M) (s : ↥S)
Goal: ((IsLocalizedModule.map S f g) h) (IsLocalizedModule.mk' f x s) = IsLocalizedModule.mk' g (h x) s
-- IsLocalizedModule.iso_localizedModule_eq_refl
lemma iso_localizedModule_eq_refl : iso S (mkLinearMap S M) = refl R (LocalizedModule S M) 
Arguments: {R : Type u_1} [CommSemiring R] (S : Submonoid R) (M : Type u_2) [AddCommMonoid M] [Module R M]
Goal: IsLocalizedModule.iso S (LocalizedModule.mkLinearMap S M) = LinearEquiv.refl R (LocalizedModule S M)
-- IsLocalizedModule.map_LocalizedModules
lemma map_LocalizedModules (g : M₀ →ₗ[R] M₁) (m : M₀) (s : S) :
    ((map S (mkLinearMap S M₀) (mkLinearMap S M₁)) g)
    (LocalizedModule.mk m s) = LocalizedModule.mk (g m) s 
Arguments: {R : Type u_1} [CommSemiring R] (S : Submonoid R) {M₀ : Type u_6} [AddCommGroup M₀] [Module R M₀] {M₁ : Type u_7} [AddCommGroup M₁] [Module R M₁] (g : M₀ →ₗ[R] M₁) (m : M₀) (s : ↥S)
Goal: ((IsLocalizedModule.map S (LocalizedModule.mkLinearMap S M₀) (LocalizedModule.mkLinearMap S M₁)) g)
    (LocalizedModule.mk m s) =
  LocalizedModule.mk (g m) s
-- IsLocalizedModule.map_iso_commute
lemma map_iso_commute (g : M₀ →ₗ[R] M₁) : (map S f₀ f₁) g ∘ₗ (iso S f₀) =
    (iso S f₁) ∘ₗ (map S (mkLinearMap S M₀) (mkLinearMap S M₁)) g 
Arguments: {R : Type u_1} [CommSemiring R] (S : Submonoid R) {M₀ : Type u_6} {M₀' : Type u_9} [AddCommGroup M₀] [AddCommGroup M₀'] [Module R M₀] [Module R M₀'] (f₀ : M₀ →ₗ[R] M₀') [IsLocalizedModule S f₀] {M₁ : Type u_7} {M₁' : Type u_8} [AddCommGroup M₁] [AddCommGroup M₁'] [Module R M₁] [Module R M₁'] (f₁ : M₁ →ₗ[R] M₁') [IsLocalizedModule S f₁] (g : M₀ →ₗ[R] M₁)
Goal: (IsLocalizedModule.map S f₀ f₁) g ∘ₗ ↑(IsLocalizedModule.iso S f₀) =
  ↑(IsLocalizedModule.iso S f₁) ∘ₗ
    (IsLocalizedModule.map S (LocalizedModule.mkLinearMap S M₀) (LocalizedModule.mkLinearMap S M₁)) g
-- LocalizedModule.map_exact
lemma map_exact (g : M₀ →ₗ[R] M₁) (h : M₁ →ₗ[R] M₂) (ex : Exact g h) :
    Exact (map S (mkLinearMap S M₀) (mkLinearMap S M₁) g)
    (map S (mkLinearMap S M₁) (mkLinearMap S M₂) h) 
Arguments: {R : Type u_1} [CommSemiring R] (S : Submonoid R) {M₀ : Type u_6} [AddCommGroup M₀] [Module R M₀] {M₁ : Type u_7} [AddCommGroup M₁] [Module R M₁] {M₂ : Type u_8} [AddCommGroup M₂] [Module R M₂] (g : M₀ →ₗ[R] M₁) (h : M₁ →ₗ[R] M₂) (ex : Function.Exact ⇑g ⇑h)
Goal: Function.Exact ⇑((IsLocalizedModule.map S (LocalizedModule.mkLinearMap S M₀) (LocalizedModule.mkLinearMap S M₁)) g)
  ⇑((IsLocalizedModule.map S (LocalizedModule.mkLinearMap S M₁) (LocalizedModule.mkLinearMap S M₂)) h)
-- IsLocalizedModule.map_exact
theorem map_exact (g : M₀ →ₗ[R] M₁) (h : M₁ →ₗ[R] M₂) (ex : Function.Exact g h) :
    Function.Exact (map S f₀ f₁ g) (map S f₁ f₂ h) 
Arguments: {R : Type u_1} [CommSemiring R] (S : Submonoid R) {M₀ : Type u_6} {M₀' : Type u_9} [AddCommGroup M₀] [AddCommGroup M₀'] [Module R M₀] [Module R M₀'] (f₀ : M₀ →ₗ[R] M₀') [IsLocalizedModule S f₀] {M₁ : Type u_7} {M₁' : Type u_10} [AddCommGroup M₁] [AddCommGroup M₁'] [Module R M₁] [Module R M₁'] (f₁ : M₁ →ₗ[R] M₁') [IsLocalizedModule S f₁] {M₂ : Type u_8} {M₂' : Type u_11} [AddCommGroup M₂] [AddCommGroup M₂'] [Module R M₂] [Module R M₂'] (f₂ : M₂ →ₗ[R] M₂') [IsLocalizedModule S f₂] (g : M₀ →ₗ[R] M₁) (h : M₁ →ₗ[R] M₂) (ex : Function.Exact ⇑g ⇑h)
Goal: Function.Exact ⇑((IsLocalizedModule.map S f₀ f₁) g) ⇑((IsLocalizedModule.map S f₁ f₂) h)
-- IsLocalizedModule.mkOfAlgebra
theorem mkOfAlgebra {R S S' : Type*} [CommRing R] [CommRing S] [CommRing S'] [Algebra R S]
    [Algebra R S'] (M : Submonoid R) (f : S →ₐ[R] S') (h₁ : ∀ x ∈ M, IsUnit (algebraMap R S' x))
    (h₂ : ∀ y, ∃ x : S × M, x.2 • y = f x.1) (h₃ : ∀ x, f x = 0 → ∃ m : M, m • x = 0) :
    IsLocalizedModule M f.toLinearMap 
Arguments: {R : Type u_6} {S : Type u_7} {S' : Type u_8} [CommRing R] [CommRing S] [CommRing S'] [Algebra R S] [Algebra R S'] (M : Submonoid R) (f : S →ₐ[R] S') (h₁ : ∀ x ∈ M, IsUnit ((algebraMap R S') x)) (h₂ : ∀ (y : S'), ∃ x, x.2 • y = f x.1) (h₃ : ∀ (x : S), f x = 0 → ∃ m, m • x = 0)
Goal: IsLocalizedModule M f.toLinearMap
-- LocalizedModule.mem_ker_mkLinearMap_iff
lemma LocalizedModule.mem_ker_mkLinearMap_iff {S : Submonoid R} {m} :
    m ∈ LinearMap.ker (LocalizedModule.mkLinearMap S M) ↔ ∃ r ∈ S, r • m = 0 
Arguments: {R : Type u_1} {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] {S : Submonoid R} {m : M}
Goal: m ∈ LinearMap.ker (LocalizedModule.mkLinearMap S M) ↔ ∃ r ∈ S, r • m = 0
-- LocalizedModule.subsingleton_iff_ker_eq_top
lemma LocalizedModule.subsingleton_iff_ker_eq_top {S : Submonoid R} :
    Subsingleton (LocalizedModule S M) ↔
      LinearMap.ker (LocalizedModule.mkLinearMap S M) = ⊤ 
Arguments: {R : Type u_1} {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] {S : Submonoid R}
Goal: Subsingleton (LocalizedModule S M) ↔ LinearMap.ker (LocalizedModule.mkLinearMap S M) = ⊤
-- LocalizedModule.subsingleton_iff
lemma LocalizedModule.subsingleton_iff {S : Submonoid R} :
    Subsingleton (LocalizedModule S M) ↔ ∀ m : M, ∃ r ∈ S, r • m = 0 
Arguments: {R : Type u_1} {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] {S : Submonoid R}
Goal: Subsingleton (LocalizedModule S M) ↔ ∀ (m : M), ∃ r ∈ S, r • m = 0
-- AlgebraCat.toModuleCatBraidedFunctor_toMonoidalFunctor
@[simps toMonoidalFunctor]
def toModuleCatBraidedFunctor : BraidedFunctor (AlgebraCat.{u} R) (ModuleCat.{u} R) 
Arguments: (R : Type u) [CommRing R]
Goal: (AlgebraCat.toModuleCatBraidedFunctor R).toMonoidalFunctor = AlgebraCat.toModuleCatMonoidalFunctor R
-- CommRingCat.pushoutCocone_inl
@[simp]
theorem pushoutCocone_inl :
    (pushoutCocone R A B).inl = Algebra.TensorProduct.includeLeftRingHom (A := A) 
Arguments: (R A B : Type u) [CommRing R] [CommRing A] [CommRing B] [Algebra R A] [Algebra R B]
Goal: (CommRingCat.pushoutCocone R A B).inl = Algebra.TensorProduct.includeLeftRingHom
-- CommRingCat.pushoutCocone_inr
@[simp]
theorem pushoutCocone_inr :
    (pushoutCocone R A B).inr = Algebra.TensorProduct.includeRight.toRingHom (A := B) 
Arguments: (R A B : Type u) [CommRing R] [CommRing A] [CommRing B] [Algebra R A] [Algebra R B]
Goal: (CommRingCat.pushoutCocone R A B).inr = Algebra.TensorProduct.includeRight.toRingHom
-- CommRingCat.pushoutCocone_pt
@[simp]
theorem pushoutCocone_pt :
    (pushoutCocone R A B).pt = CommRingCat.of (A ⊗[R] B) 
Arguments: (R A B : Type u) [CommRing R] [CommRing A] [CommRing B] [Algebra R A] [Algebra R B]
Goal: (CommRingCat.pushoutCocone R A B).pt = CommRingCat.of (A ⊗[R] B)
-- CommRingCat.subsingleton_of_isTerminal
theorem subsingleton_of_isTerminal {X : CommRingCat} (hX : IsTerminal X) : Subsingleton X 
Arguments: {X : CommRingCat} (hX : CategoryTheory.Limits.IsTerminal X)
Goal: Subsingleton ↑X
-- CommRingCat.prodFan_pt
@[simps! pt]
def prodFan : BinaryFan A B 
Arguments: (A B : CommRingCat)
Goal: (A.prodFan B).pt = CommRingCat.of (↑A × ↑B)
-- CommRingCat.piFan_pt
@[simps! pt]
def piFan : Fan R 
Arguments: {ι : Type u} (R : ι → CommRingCat)
Goal: (CommRingCat.piFan R).pt = CommRingCat.of ((i : ι) → ↑(R i))
-- PresheafOfModules.map_smul
structure PresheafOfModules (R : Cᵒᵖ ⥤ RingCat.{u}) where
  presheaf : Cᵒᵖ ⥤ AddCommGrp.{v}
  module : ∀ X : Cᵒᵖ, Module (R.obj X) (presheaf.obj X) := by infer_instance
  map_smul : ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y) (r : R.obj X) (x : presheaf.obj X),
    presheaf.map f (r • x) = R.map f r • presheaf.map f x := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} (self : PresheafOfModules R) {X Y : Cᵒᵖ} (f : X ⟶ Y) (r : ↑(R.obj X)) (x : ↑(self.presheaf.obj X))
Goal: (self.presheaf.map f) (r • x) = (R.map f) r • (self.presheaf.map f) x
-- PresheafOfModules.map_apply
theorem map_apply (P : PresheafOfModules R) {X Y : Cᵒᵖ} (f : X ⟶ Y) (x) :
    P.map f x = (P.presheaf.map f) x 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} (P : PresheafOfModules R) {X Y : Cᵒᵖ} (f : X ⟶ Y) (x : ↑(P.obj X))
Goal: (P.map f) x = (P.presheaf.map f) x
-- PresheafOfModules.map_id
@[simp]
theorem map_id (P : PresheafOfModules R) (X : Cᵒᵖ) :
    P.map (𝟙 X) = LinearMap.id' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} (P : PresheafOfModules R) (X : Cᵒᵖ)
Goal: P.map (𝟙 X) = LinearMap.id'
-- PresheafOfModules.map_comp
@[simp]
theorem map_comp (P : PresheafOfModules R) {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z) :
    P.map (f ≫ g) = (P.map g).comp (P.map f) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} (P : PresheafOfModules R) {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: P.map (f ≫ g) = (P.map g).comp (P.map f)
-- PresheafOfModules.Hom.map_smul
structure Hom (P Q : PresheafOfModules R) where
  hom : P.presheaf ⟶ Q.presheaf
  map_smul : ∀ (X : Cᵒᵖ) (r : R.obj X) (x : P.presheaf.obj X), hom.app X (r • x) = r • hom.app X x
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {P Q : PresheafOfModules R} (self : P.Hom Q) (X : Cᵒᵖ) (r : ↑(R.obj X)) (x : ↑(P.presheaf.obj X))
Goal: (self.hom.app X) (r • x) = r • (self.hom.app X) x
-- PresheafOfModules.Hom.id_hom
@[simp]
lemma id_hom : Hom.hom (𝟙 P) = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} (P : PresheafOfModules R)
Goal: (𝟙 P).hom = 𝟙 P.presheaf
-- PresheafOfModules.Hom.comp_hom
@[simp, reassoc]
lemma comp_hom (f : P ⟶ Q) (g : Q ⟶ T) : (f ≫ g).hom = f.hom ≫ g.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {P Q T : PresheafOfModules R} (f : P ⟶ Q) (g : Q ⟶ T)
Goal: (f ≫ g).hom = f.hom ≫ g.hom
-- PresheafOfModules.Hom.comp_app
@[simp]
lemma comp_app (f : P ⟶ Q) (g : Q ⟶ T) (X : Cᵒᵖ) :
    (f ≫ g).app X = (g.app X).comp (f.app X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {P Q T : PresheafOfModules R} (f : P ⟶ Q) (g : Q ⟶ T) (X : Cᵒᵖ)
Goal: PresheafOfModules.Hom.app (f ≫ g) X = PresheafOfModules.Hom.app g X ∘ₗ PresheafOfModules.Hom.app f X
-- PresheafOfModules.Hom.ext
@[ext]
theorem ext {f g : P ⟶ Q} (w : ∀ X, f.app X = g.app X) : f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {P Q : PresheafOfModules R} {f g : P ⟶ Q} (w : ∀ (X : Cᵒᵖ), PresheafOfModules.Hom.app f X = PresheafOfModules.Hom.app g X)
Goal: f = g
-- PresheafOfModules.Hom.zero_app
@[simp]
lemma zero_app (X : Cᵒᵖ) : (0 : P ⟶ Q).app X = 0 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} (P Q : PresheafOfModules R) (X : Cᵒᵖ)
Goal: PresheafOfModules.Hom.app 0 X = 0
-- PresheafOfModules.Hom.add_app
@[simp]
lemma add_app (f g : P ⟶ Q) (X : Cᵒᵖ) : (f + g).app X = f.app X + g.app X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {P Q : PresheafOfModules R} (f g : P ⟶ Q) (X : Cᵒᵖ)
Goal: PresheafOfModules.Hom.app (f + g) X = PresheafOfModules.Hom.app f X + PresheafOfModules.Hom.app g X
-- PresheafOfModules.Hom.sub_app
@[simp]
lemma sub_app (f g : P ⟶ Q) (X : Cᵒᵖ) : (f - g).app X = f.app X - g.app X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {P Q : PresheafOfModules R} (f g : P ⟶ Q) (X : Cᵒᵖ)
Goal: PresheafOfModules.Hom.app (f - g) X = PresheafOfModules.Hom.app f X - PresheafOfModules.Hom.app g X
-- PresheafOfModules.Hom.neg_app
@[simp]
lemma neg_app (f : P ⟶ Q) (X : Cᵒᵖ) : (-f).app X = -f.app X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {P Q : PresheafOfModules R} (f : P ⟶ Q) (X : Cᵒᵖ)
Goal: PresheafOfModules.Hom.app (-f) X = -PresheafOfModules.Hom.app f X
-- PresheafOfModules.naturality_apply
lemma naturality_apply {P Q : PresheafOfModules R} (f : P ⟶ Q)
    {X Y : Cᵒᵖ} (g : X ⟶ Y) (x : P.obj X) :
    f.app Y (P.map g x) = Q.map g (f.app X x) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {P Q : PresheafOfModules R} (f : P ⟶ Q) {X Y : Cᵒᵖ} (g : X ⟶ Y) (x : ↑(P.obj X))
Goal: (PresheafOfModules.Hom.app f Y) ((P.map g) x) = (Q.map g) ((PresheafOfModules.Hom.app f X) x)
-- PresheafOfModules.toPresheaf_obj
@[simps obj]
def toPresheaf : PresheafOfModules.{v} R ⥤ (Cᵒᵖ ⥤ AddCommGrp.{v}) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (R : Cᵒᵖ ⥤ RingCat) (P : PresheafOfModules R)
Goal: (PresheafOfModules.toPresheaf R).obj P = P.presheaf
-- PresheafOfModules.toPresheaf_map_app
@[simp]
lemma toPresheaf_map_app {P Q : PresheafOfModules R}
    (f : P ⟶ Q) (X : Cᵒᵖ) :
    ((toPresheaf R).map f).app X = (f.app X).toAddMonoidHom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {P Q : PresheafOfModules R} (f : P ⟶ Q) (X : Cᵒᵖ)
Goal: ((PresheafOfModules.toPresheaf R).map f).app X = (PresheafOfModules.Hom.app f X).toAddMonoidHom
-- PresheafOfModules.evaluation_obj
@[simps]
def evaluation (X : Cᵒᵖ) : PresheafOfModules.{v} R ⥤ ModuleCat (R.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (R : Cᵒᵖ ⥤ RingCat) (X : Cᵒᵖ) (M : PresheafOfModules R)
Goal: (PresheafOfModules.evaluation R X).obj M = M.obj X
-- PresheafOfModules.evaluation_map
@[simps]
def evaluation (X : Cᵒᵖ) : PresheafOfModules.{v} R ⥤ ModuleCat (R.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (R : Cᵒᵖ ⥤ RingCat) (X : Cᵒᵖ)
Goal: ∀ {X_1 Y : PresheafOfModules R} (f : X_1 ⟶ Y), (PresheafOfModules.evaluation R X).map f = PresheafOfModules.Hom.app f X
-- PresheafOfModules.restrictionApp_apply
lemma restrictionApp_apply {X Y : Cᵒᵖ} (f : X ⟶ Y) (M : PresheafOfModules R) (x : M.obj X) :
    restrictionApp f M x = M.map f x 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {X Y : Cᵒᵖ} (f : X ⟶ Y) (M : PresheafOfModules R) (x : ↑(M.obj X))
Goal: (PresheafOfModules.restrictionApp f M) x = (M.map f) x
-- PresheafOfModules.restriction_app
@[simps]
noncomputable def restriction {X Y : Cᵒᵖ} (f : X ⟶ Y) :
    evaluation R X ⟶ evaluation R Y ⋙ ModuleCat.restrictScalars (R.map f) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (R : Cᵒᵖ ⥤ RingCat) {X Y : Cᵒᵖ} (f : X ⟶ Y) (M : PresheafOfModules R)
Goal: (PresheafOfModules.restriction R f).app M = PresheafOfModules.restrictionApp f M
-- PresheafOfModules.restrictionApp_naturality
@[reassoc (attr := simp)]
lemma restrictionApp_naturality {X Y : Cᵒᵖ} (f : X ⟶ Y)
    {M N : PresheafOfModules R} (φ : M ⟶ N) :
    restrictionApp f M ≫ (ModuleCat.restrictScalars (R.map f)).map (Hom.app φ Y) =
      ModuleCat.ofHom (Hom.app φ X) ≫ restrictionApp f N 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {X Y : Cᵒᵖ} (f : X ⟶ Y) {M N : PresheafOfModules R} (φ : M ⟶ N)
Goal: PresheafOfModules.restrictionApp f M ≫ (ModuleCat.restrictScalars (R.map f)).map (PresheafOfModules.Hom.app φ Y) =
  ModuleCat.ofHom (PresheafOfModules.Hom.app φ X) ≫ PresheafOfModules.restrictionApp f N
-- PresheafOfModules.restrictionApp_id
lemma restrictionApp_id (M : PresheafOfModules R) (X : Cᵒᵖ) :
    restrictionApp (𝟙 X) M =
      (ModuleCat.restrictScalarsId' (R.map (𝟙 X)) (R.map_id X)).inv.app (M.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} (M : PresheafOfModules R) (X : Cᵒᵖ)
Goal: PresheafOfModules.restrictionApp (𝟙 X) M = (ModuleCat.restrictScalarsId' (R.map (𝟙 X)) ⋯).inv.app (M.obj X)
-- PresheafOfModules.restrictionApp_comp
lemma restrictionApp_comp (M : PresheafOfModules R) {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z) :
    restrictionApp (f ≫ g) M =
      restrictionApp f M ≫
        (ModuleCat.restrictScalars (R.map f)).map (restrictionApp g M) ≫
        (ModuleCat.restrictScalarsComp' _ _ _ (R.map_comp f g)).inv.app (M.obj Z) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} (M : PresheafOfModules R) {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: PresheafOfModules.restrictionApp (f ≫ g) M =
  PresheafOfModules.restrictionApp f M ≫
    (ModuleCat.restrictScalars (R.map f)).map (PresheafOfModules.restrictionApp g M) ≫
      (ModuleCat.restrictScalarsComp' (R.map f) (R.map g) (R.map (f ≫ g)) ⋯).inv.app (M.obj Z)
-- PresheafOfModules.Hom.mk'_app
@[simp]
lemma mk'_app : (mk' app naturality).app = app 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : Cᵒᵖ ⥤ RingCat} {P Q : PresheafOfModules R} (app : (X : Cᵒᵖ) → ↑(P.obj X) →ₗ[↑(R.obj X)] ↑(Q.obj X)) (naturality : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y) (x : ↑(P.obj X)), (app Y) ((P.map f) x) = (Q.map f) ((app X) x))
Goal: PresheafOfModules.Hom.app (PresheafOfModules.Hom.mk' app naturality) = app