ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AddMonoidHom.id_addCommGrp_comp
@[to_additive (attr := simp)] theorem MonoidHom.id_commGrp_comp
    {G : Type u} [CommGroup G] {H : CommGrp.{u}} (f : G →* H) : MonoidHom.comp (𝟙 H) f = f 
Arguments: {G : Type u} [AddCommGroup G] {H : AddCommGrp} (f : G →+ ↑H)
Goal: AddMonoidHom.comp (𝟙 H) f = f
-- PresheafOfModules.Derivation.d_app
@[ext]
structure Derivation where
    d {X : Dᵒᵖ} : R.obj X →+ M.obj X
  d_mul {X : Dᵒᵖ} (a b : R.obj X) : d (a * b) = a • d b + b • d a := by aesop_cat
  d_map {X Y : Dᵒᵖ} (f : X ⟶ Y) (x : R.obj X) :
    d (R.map f x) = M.map f (d x) := by aesop_cat
  d_app {X : Cᵒᵖ} (a : S.obj X) : d (φ.app X a) = 0 := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : Cᵒᵖ ⥤ CommRingCat} {F : C ⥤ D} {R : Dᵒᵖ ⥤ CommRingCat} {M : PresheafOfModules (R ⋙ CategoryTheory.forget₂ CommRingCat RingCat)} {φ : S ⟶ F.op ⋙ R} (self : M.Derivation φ) {X : Cᵒᵖ} (a : ↑(S.obj X))
Goal: self.d ((φ.app X) a) = 0
-- PresheafOfModules.Derivation.d_map
@[ext]
structure Derivation where
    d {X : Dᵒᵖ} : R.obj X →+ M.obj X
  d_mul {X : Dᵒᵖ} (a b : R.obj X) : d (a * b) = a • d b + b • d a := by aesop_cat
  d_map {X Y : Dᵒᵖ} (f : X ⟶ Y) (x : R.obj X) :
    d (R.map f x) = M.map f (d x) := by aesop_cat
  d_app {X : Cᵒᵖ} (a : S.obj X) : d (φ.app X a) = 0 := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : Cᵒᵖ ⥤ CommRingCat} {F : C ⥤ D} {R : Dᵒᵖ ⥤ CommRingCat} {M : PresheafOfModules (R ⋙ CategoryTheory.forget₂ CommRingCat RingCat)} {φ : S ⟶ F.op ⋙ R} (self : M.Derivation φ) {X Y : Dᵒᵖ} (f : X ⟶ Y) (x : ↑(R.obj X))
Goal: self.d ((R.map f) x) = (M.map f) (self.d x)
-- PresheafOfModules.Derivation.d_mul
@[ext]
structure Derivation where
    d {X : Dᵒᵖ} : R.obj X →+ M.obj X
  d_mul {X : Dᵒᵖ} (a b : R.obj X) : d (a * b) = a • d b + b • d a := by aesop_cat
  d_map {X Y : Dᵒᵖ} (f : X ⟶ Y) (x : R.obj X) :
    d (R.map f x) = M.map f (d x) := by aesop_cat
  d_app {X : Cᵒᵖ} (a : S.obj X) : d (φ.app X a) = 0 := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : Cᵒᵖ ⥤ CommRingCat} {F : C ⥤ D} {R : Dᵒᵖ ⥤ CommRingCat} {M : PresheafOfModules (R ⋙ CategoryTheory.forget₂ CommRingCat RingCat)} {φ : S ⟶ F.op ⋙ R} (self : M.Derivation φ) {X : Dᵒᵖ} (a b : ↑(R.obj X))
Goal: self.d (a * b) = a • self.d b + b • self.d a
-- PresheafOfModules.Derivation.congr_d
lemma congr_d {d d' : M.Derivation φ} (h : d = d') {X : Dᵒᵖ} (b : R.obj X) :
    d.d b = d'.d b 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : Cᵒᵖ ⥤ CommRingCat} {F : C ⥤ D} {R : Dᵒᵖ ⥤ CommRingCat} {M : PresheafOfModules (R ⋙ CategoryTheory.forget₂ CommRingCat RingCat)} {φ : S ⟶ F.op ⋙ R} {d d' : M.Derivation φ} (h : d = d') {X : Dᵒᵖ} (b : ↑(R.obj X))
Goal: d.d b = d'.d b
-- PresheafOfModules.Derivation.d_one
@[simp] lemma d_one (X : Dᵒᵖ) : d.d (X := X) 1 = 0 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : Cᵒᵖ ⥤ CommRingCat} {F : C ⥤ D} {R : Dᵒᵖ ⥤ CommRingCat} {M : PresheafOfModules (R ⋙ CategoryTheory.forget₂ CommRingCat RingCat)} {φ : S ⟶ F.op ⋙ R} (d : M.Derivation φ) (X : Dᵒᵖ)
Goal: d.d 1 = 0
-- PresheafOfModules.Derivation.postcomp_d_apply
@[simps! d_apply]
def postcomp (f : M ⟶ N) : N.Derivation φ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : Cᵒᵖ ⥤ CommRingCat} {F : C ⥤ D} {R : Dᵒᵖ ⥤ CommRingCat} {M N : PresheafOfModules (R ⋙ CategoryTheory.forget₂ CommRingCat RingCat)} {φ : S ⟶ F.op ⋙ R} (d : M.Derivation φ) (f : M ⟶ N)
Goal: ∀ {X : Dᵒᵖ} (a : ↑(R.obj X)), (d.postcomp f).d a = (PresheafOfModules.Hom.app f X) (d.d a)
-- PresheafOfModules.Derivation.Universal.postcomp_injective
structure Universal where
    desc {M' : PresheafOfModules (R ⋙ forget₂ CommRingCat RingCat)}
    (d' : M'.Derivation φ) : M ⟶ M'
  fac {M' : PresheafOfModules (R ⋙ forget₂ CommRingCat RingCat)}
    (d' : M'.Derivation φ) : d.postcomp (desc d') = d' := by aesop_cat
  postcomp_injective {M' : PresheafOfModules (R ⋙ forget₂ CommRingCat RingCat)}
    (φ φ' : M ⟶ M') (h : d.postcomp φ = d.postcomp φ') : φ = φ' := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : Cᵒᵖ ⥤ CommRingCat} {F : C ⥤ D} {R : Dᵒᵖ ⥤ CommRingCat} {M : PresheafOfModules (R ⋙ CategoryTheory.forget₂ CommRingCat RingCat)} {φ : S ⟶ F.op ⋙ R} {d : M.Derivation φ} (self : d.Universal) {M' : PresheafOfModules (R ⋙ CategoryTheory.forget₂ CommRingCat RingCat)}
Goal: ∀ (φ_1 φ' : M ⟶ M'), d.postcomp φ_1 = d.postcomp φ' → φ_1 = φ'
-- PresheafOfModules.Derivation.Universal.fac
structure Universal where
    desc {M' : PresheafOfModules (R ⋙ forget₂ CommRingCat RingCat)}
    (d' : M'.Derivation φ) : M ⟶ M'
  fac {M' : PresheafOfModules (R ⋙ forget₂ CommRingCat RingCat)}
    (d' : M'.Derivation φ) : d.postcomp (desc d') = d' := by aesop_cat
  postcomp_injective {M' : PresheafOfModules (R ⋙ forget₂ CommRingCat RingCat)}
    (φ φ' : M ⟶ M') (h : d.postcomp φ = d.postcomp φ') : φ = φ' := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : Cᵒᵖ ⥤ CommRingCat} {F : C ⥤ D} {R : Dᵒᵖ ⥤ CommRingCat} {M : PresheafOfModules (R ⋙ CategoryTheory.forget₂ CommRingCat RingCat)} {φ : S ⟶ F.op ⋙ R} {d : M.Derivation φ} (self : d.Universal) {M' : PresheafOfModules (R ⋙ CategoryTheory.forget₂ CommRingCat RingCat)} (d' : M'.Derivation φ)
Goal: d.postcomp (self.desc d') = d'
-- PresheafOfModules.HasDifferentials.exists_universal_derivation
class HasDifferentials : Prop where
  exists_universal_derivation : ∃ (M : PresheafOfModules.{u} (R ⋙ forget₂ _ _))
      (d : M.Derivation φ), Nonempty d.Universal
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : Cᵒᵖ ⥤ CommRingCat} {F : C ⥤ D} {R : Dᵒᵖ ⥤ CommRingCat} {φ : S ⟶ F.op ⋙ R} [self : PresheafOfModules.HasDifferentials φ]
Goal: ∃ M d, Nonempty d.Universal
-- PresheafOfModules.Derivation'.d_app
@[simp]
nonrec lemma d_app (d : M.Derivation' φ') {X : Dᵒᵖ} (a : S'.obj X) :
    d.d (φ'.app X a) = 0 
Arguments: {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S' R : Dᵒᵖ ⥤ CommRingCat} {M : PresheafOfModules (R ⋙ CategoryTheory.forget₂ CommRingCat RingCat)} {φ' : S' ⟶ R} (d : M.Derivation' φ') {X : Dᵒᵖ} (a : ↑(S'.obj X))
Goal: d.d ((φ'.app X) a) = 0
-- PresheafOfModules.Derivation'.app_apply
@[simp]
lemma app_apply (d : M.Derivation' φ') {X : Dᵒᵖ} (b : R.obj X) :
    (d.app X).d b = d.d b 
Arguments: {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S' R : Dᵒᵖ ⥤ CommRingCat} {M : PresheafOfModules (R ⋙ CategoryTheory.forget₂ CommRingCat RingCat)} {φ' : S' ⟶ R} (d : M.Derivation' φ') {X : Dᵒᵖ} (b : ↑(R.obj X))
Goal: (d.app X).d b = d.d b
-- PresheafOfModules.Derivation'.mk_app
@[simp]
lemma mk_app (X : Dᵒᵖ) : (mk d d_map).app X = d X 
Arguments: {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S' R : Dᵒᵖ ⥤ CommRingCat} {M : PresheafOfModules (R ⋙ CategoryTheory.forget₂ CommRingCat RingCat)} {φ' : S' ⟶ R} (d : (X : Dᵒᵖ) → (M.obj X).Derivation (φ'.app X)) (d_map : ∀ ⦃X Y : Dᵒᵖ⦄ (f : X ⟶ Y) (x : ↑(R.obj X)), (d Y).d ((R.map f) x) = (M.map f) ((d X).d x)) (X : Dᵒᵖ)
Goal: (PresheafOfModules.Derivation'.mk d d_map).app X = d X
-- PresheafOfModules.DifferentialsConstruction.relativeDifferentials'_obj
@[simp]
lemma relativeDifferentials'_obj (X : Dᵒᵖ) :
    (relativeDifferentials' φ').obj X =
      CommRingCat.KaehlerDifferential (φ'.app X) 
Arguments: {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S' R : Dᵒᵖ ⥤ CommRingCat} (φ' : S' ⟶ R) (X : Dᵒᵖ)
Goal: (PresheafOfModules.DifferentialsConstruction.relativeDifferentials' φ').obj X =
  CommRingCat.KaehlerDifferential (φ'.app X)
-- PresheafOfModules.DifferentialsConstruction.relativeDifferentials'_map_apply
lemma relativeDifferentials'_map_apply {X Y : Dᵒᵖ} (f : X ⟶ Y)
    (x : CommRingCat.KaehlerDifferential (φ'.app X)) :
    (relativeDifferentials' φ').map f x =
        CommRingCat.KaehlerDifferential.map (φ'.naturality f) x 
Arguments: {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S' R : Dᵒᵖ ⥤ CommRingCat} (φ' : S' ⟶ R) {X Y : Dᵒᵖ} (f : X ⟶ Y) (x : ↑(CommRingCat.KaehlerDifferential (φ'.app X)))
Goal: ((PresheafOfModules.DifferentialsConstruction.relativeDifferentials' φ').map f) x =
  (CommRingCat.KaehlerDifferential.map ⋯) x
-- PresheafOfModules.DifferentialsConstruction.relativeDifferentials'_map_d
lemma relativeDifferentials'_map_d {X Y : Dᵒᵖ} (f : X ⟶ Y)
    (x : R.obj X) :
    (relativeDifferentials' φ').map f (CommRingCat.KaehlerDifferential.d x) =
      CommRingCat.KaehlerDifferential.d (R.map f x) 
Arguments: {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S' R : Dᵒᵖ ⥤ CommRingCat} (φ' : S' ⟶ R) {X Y : Dᵒᵖ} (f : X ⟶ Y) (x : ↑(R.obj X))
Goal: ((PresheafOfModules.DifferentialsConstruction.relativeDifferentials' φ').map f) (CommRingCat.KaehlerDifferential.d x) =
  CommRingCat.KaehlerDifferential.d ((R.map f) x)
-- AddGrp.isZero_of_subsingleton
@[to_additive]
theorem isZero_of_subsingleton (G : Grp) [Subsingleton G] : IsZero G 
Arguments: (G : AddGrp) [Subsingleton ↑G]
Goal: CategoryTheory.Limits.IsZero G
-- Grp.isZero_of_subsingleton
@[to_additive]
theorem isZero_of_subsingleton (G : Grp) [Subsingleton G] : IsZero G 
Arguments: (G : Grp) [Subsingleton ↑G]
Goal: CategoryTheory.Limits.IsZero G
-- CommGrp.isZero_of_subsingleton
@[to_additive]
theorem isZero_of_subsingleton (G : CommGrp) [Subsingleton G] : IsZero G 
Arguments: (G : CommGrp) [Subsingleton ↑G]
Goal: CategoryTheory.Limits.IsZero G
-- AddCommGrp.isZero_of_subsingleton
@[to_additive]
theorem isZero_of_subsingleton (G : CommGrp) [Subsingleton G] : IsZero G 
Arguments: (G : AddCommGrp) [Subsingleton ↑G]
Goal: CategoryTheory.Limits.IsZero G
-- ModuleCat.MonoidalCategory.tensor_id
theorem tensor_id (M N : ModuleCat R) : tensorHom (𝟙 M) (𝟙 N) = 𝟙 (ModuleCat.of R (M ⊗ N)) 
Arguments: {R : Type u} [CommRing R] (M : ModuleCat R) (N : ModuleCat R)
Goal: ModuleCat.MonoidalCategory.tensorHom (𝟙 M) (𝟙 N) = 𝟙 (ModuleCat.of R (TensorProduct R ↑M ↑N))
-- ModuleCat.MonoidalCategory.tensor_comp
theorem tensor_comp {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : ModuleCat R} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (g₁ : Y₁ ⟶ Z₁)
    (g₂ : Y₂ ⟶ Z₂) : tensorHom (f₁ ≫ g₁) (f₂ ≫ g₂) = tensorHom f₁ f₂ ≫ tensorHom g₁ g₂ 
Arguments: {R : Type u} [CommRing R] {X₁ Y₁ Z₁ : ModuleCat R} {X₂ Y₂ Z₂ : ModuleCat R} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (g₁ : Y₁ ⟶ Z₁) (g₂ : Y₂ ⟶ Z₂)
Goal: ModuleCat.MonoidalCategory.tensorHom (f₁ ≫ g₁) (f₂ ≫ g₂) =
  ModuleCat.MonoidalCategory.tensorHom f₁ f₂ ≫ ModuleCat.MonoidalCategory.tensorHom g₁ g₂
-- ModuleCat.MonoidalCategory.instMonoidalCategoryStruct_tensorObj
@[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R) 
Arguments: {R : Type u} [CommRing R] (M N : ModuleCat R)
Goal: CategoryTheory.MonoidalCategory.tensorObj M N = ModuleCat.MonoidalCategory.tensorObj M N
-- ModuleCat.MonoidalCategory.instMonoidalCategoryStruct_tensorUnit
@[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R) 
Arguments: {R : Type u} [CommRing R]
Goal: 𝟙_ (ModuleCat R) = ModuleCat.of R R
-- ModuleCat.MonoidalCategory.instMonoidalCategoryStruct_rightUnitor
@[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R) 
Arguments: {R : Type u} [CommRing R] (M : ModuleCat R)
Goal: CategoryTheory.MonoidalCategory.rightUnitor M = ModuleCat.MonoidalCategory.rightUnitor M
-- ModuleCat.MonoidalCategory.instMonoidalCategoryStruct_tensorHom
@[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R) 
Arguments: {R : Type u} [CommRing R]
Goal: ∀ {X₁ Y₁ X₂ Y₂ : ModuleCat R} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
  CategoryTheory.MonoidalCategory.tensorHom f g = TensorProduct.map f g
-- ModuleCat.MonoidalCategory.instMonoidalCategoryStruct_whiskerRight
@[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R) 
Arguments: {R : Type u} [CommRing R]
Goal: ∀ {X₁ X₂ : ModuleCat R} (f : X₁ ⟶ X₂) (N : ModuleCat R),
  CategoryTheory.MonoidalCategory.whiskerRight f N = ModuleCat.MonoidalCategory.whiskerRight f N
-- ModuleCat.MonoidalCategory.instMonoidalCategoryStruct_whiskerLeft
@[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R) 
Arguments: {R : Type u} [CommRing R] (M : ModuleCat R) {N₁ N₂ : ModuleCat R} (f : N₁ ⟶ N₂)
Goal: CategoryTheory.MonoidalCategory.whiskerLeft M f = ModuleCat.MonoidalCategory.whiskerLeft M f
-- ModuleCat.MonoidalCategory.instMonoidalCategoryStruct_leftUnitor
@[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R) 
Arguments: {R : Type u} [CommRing R] (M : ModuleCat R)
Goal: CategoryTheory.MonoidalCategory.leftUnitor M = ModuleCat.MonoidalCategory.leftUnitor M
-- ModuleCat.MonoidalCategory.instMonoidalCategoryStruct_associator
@[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R) 
Arguments: {R : Type u} [CommRing R] (M N K : ModuleCat R)
Goal: CategoryTheory.MonoidalCategory.associator M N K = ModuleCat.MonoidalCategory.associator M N K
-- _private.Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic.0.ModuleCat.MonoidalCategory.associator_naturality_aux
private theorem associator_naturality_aux {X₁ X₂ X₃ : Type*} [AddCommMonoid X₁] [AddCommMonoid X₂]
    [AddCommMonoid X₃] [Module R X₁] [Module R X₂] [Module R X₃] {Y₁ Y₂ Y₃ : Type*}
    [AddCommMonoid Y₁] [AddCommMonoid Y₂] [AddCommMonoid Y₃] [Module R Y₁] [Module R Y₂]
    [Module R Y₃] (f₁ : X₁ →ₗ[R] Y₁) (f₂ : X₂ →ₗ[R] Y₂) (f₃ : X₃ →ₗ[R] Y₃) :
    ↑(assoc R Y₁ Y₂ Y₃) ∘ₗ map (map f₁ f₂) f₃ = map f₁ (map f₂ f₃) ∘ₗ ↑(assoc R X₁ X₂ X₃) 
Arguments: {R : Type u} [CommRing R] {X₁ : Type u_1} {X₂ : Type u_2} {X₃ : Type u_3} [AddCommMonoid X₁] [AddCommMonoid X₂] [AddCommMonoid X₃] [Module R X₁] [Module R X₂] [Module R X₃] {Y₁ : Type u_4} {Y₂ : Type u_5} {Y₃ : Type u_6} [AddCommMonoid Y₁] [AddCommMonoid Y₂] [AddCommMonoid Y₃] [Module R Y₁] [Module R Y₂] [Module R Y₃] (f₁ : X₁ →ₗ[R] Y₁) (f₂ : X₂ →ₗ[R] Y₂) (f₃ : X₃ →ₗ[R] Y₃)
Goal: ↑(TensorProduct.assoc R Y₁ Y₂ Y₃) ∘ₗ TensorProduct.map (TensorProduct.map f₁ f₂) f₃ =
  TensorProduct.map f₁ (TensorProduct.map f₂ f₃) ∘ₗ ↑(TensorProduct.assoc R X₁ X₂ X₃)
-- _private.Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic.0.ModuleCat.MonoidalCategory.pentagon_aux
private theorem pentagon_aux (W X Y Z : Type*) [AddCommMonoid W] [AddCommMonoid X]
    [AddCommMonoid Y] [AddCommMonoid Z] [Module R W] [Module R X] [Module R Y] [Module R Z] :
    (((assoc R X Y Z).toLinearMap.lTensor W).comp
            (assoc R W (X ⊗[R] Y) Z).toLinearMap).comp
        ((assoc R W X Y).toLinearMap.rTensor Z) =
      (assoc R W X (Y ⊗[R] Z)).toLinearMap.comp (assoc R (W ⊗[R] X) Y Z).toLinearMap 
Arguments: (R : Type u) [CommRing R] (W : Type u_1) (X : Type u_2) (Y : Type u_3) (Z : Type u_4) [AddCommMonoid W] [AddCommMonoid X] [AddCommMonoid Y] [AddCommMonoid Z] [Module R W] [Module R X] [Module R Y] [Module R Z]
Goal: (LinearMap.lTensor W ↑(TensorProduct.assoc R X Y Z) ∘ₗ ↑(TensorProduct.assoc R W (TensorProduct R X Y) Z)) ∘ₗ
    LinearMap.rTensor Z ↑(TensorProduct.assoc R W X Y) =
  ↑(TensorProduct.assoc R W X (TensorProduct R Y Z)) ∘ₗ ↑(TensorProduct.assoc R (TensorProduct R W X) Y Z)
-- ModuleCat.MonoidalCategory.associator_naturality
theorem associator_naturality {X₁ X₂ X₃ Y₁ Y₂ Y₃ : ModuleCat R} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂)
    (f₃ : X₃ ⟶ Y₃) :
    tensorHom (tensorHom f₁ f₂) f₃ ≫ (associator Y₁ Y₂ Y₃).hom =
      (associator X₁ X₂ X₃).hom ≫ tensorHom f₁ (tensorHom f₂ f₃) 
Arguments: {R : Type u} [CommRing R] {X₁ : ModuleCat R} {X₂ : ModuleCat R} {X₃ : ModuleCat R} {Y₁ : ModuleCat R} {Y₂ : ModuleCat R} {Y₃ : ModuleCat R} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃ : X₃ ⟶ Y₃)
Goal: ModuleCat.MonoidalCategory.tensorHom (ModuleCat.MonoidalCategory.tensorHom f₁ f₂) f₃ ≫
    (ModuleCat.MonoidalCategory.associator Y₁ Y₂ Y₃).hom =
  (ModuleCat.MonoidalCategory.associator X₁ X₂ X₃).hom ≫
    ModuleCat.MonoidalCategory.tensorHom f₁ (ModuleCat.MonoidalCategory.tensorHom f₂ f₃)
-- ModuleCat.MonoidalCategory.pentagon
theorem pentagon (W X Y Z : ModuleCat R) :
    whiskerRight (associator W X Y).hom Z ≫
        (associator W (tensorObj X Y) Z).hom ≫ whiskerLeft W (associator X Y Z).hom =
      (associator (tensorObj W X) Y Z).hom ≫ (associator W X (tensorObj Y Z)).hom 
Arguments: {R : Type u} [CommRing R] (W : ModuleCat R) (X : ModuleCat R) (Y : ModuleCat R) (Z : ModuleCat R)
Goal: ModuleCat.MonoidalCategory.whiskerRight (ModuleCat.MonoidalCategory.associator W X Y).hom Z ≫
    (ModuleCat.MonoidalCategory.associator W (ModuleCat.MonoidalCategory.tensorObj X Y) Z).hom ≫
      ModuleCat.MonoidalCategory.whiskerLeft W (ModuleCat.MonoidalCategory.associator X Y Z).hom =
  (ModuleCat.MonoidalCategory.associator (ModuleCat.MonoidalCategory.tensorObj W X) Y Z).hom ≫
    (ModuleCat.MonoidalCategory.associator W X (ModuleCat.MonoidalCategory.tensorObj Y Z)).hom
-- ModuleCat.MonoidalCategory.leftUnitor_naturality
theorem leftUnitor_naturality {M N : ModuleCat R} (f : M ⟶ N) :
    tensorHom (𝟙 (ModuleCat.of R R)) f ≫ (leftUnitor N).hom = (leftUnitor M).hom ≫ f 
Arguments: {R : Type u} [CommRing R] {M N : ModuleCat R} (f : M ⟶ N)
Goal: ModuleCat.MonoidalCategory.tensorHom (𝟙 (ModuleCat.of R R)) f ≫ (ModuleCat.MonoidalCategory.leftUnitor N).hom =
  (ModuleCat.MonoidalCategory.leftUnitor M).hom ≫ f
-- ModuleCat.MonoidalCategory.rightUnitor_naturality
theorem rightUnitor_naturality {M N : ModuleCat R} (f : M ⟶ N) :
    tensorHom f (𝟙 (ModuleCat.of R R)) ≫ (rightUnitor N).hom = (rightUnitor M).hom ≫ f 
Arguments: {R : Type u} [CommRing R] {M N : ModuleCat R} (f : M ⟶ N)
Goal: ModuleCat.MonoidalCategory.tensorHom f (𝟙 (ModuleCat.of R R)) ≫ (ModuleCat.MonoidalCategory.rightUnitor N).hom =
  (ModuleCat.MonoidalCategory.rightUnitor M).hom ≫ f
-- ModuleCat.MonoidalCategory.triangle
theorem triangle (M N : ModuleCat.{u} R) :
    (associator M (ModuleCat.of R R) N).hom ≫ tensorHom (𝟙 M) (leftUnitor N).hom =
      tensorHom (rightUnitor M).hom (𝟙 N) 
Arguments: {R : Type u} [CommRing R] (M N : ModuleCat R)
Goal: (ModuleCat.MonoidalCategory.associator M (ModuleCat.of R R) N).hom ≫
    ModuleCat.MonoidalCategory.tensorHom (𝟙 M) (ModuleCat.MonoidalCategory.leftUnitor N).hom =
  ModuleCat.MonoidalCategory.tensorHom (ModuleCat.MonoidalCategory.rightUnitor M).hom (𝟙 N)
-- ModuleCat.MonoidalCategory.hom_apply
@[simp]
theorem hom_apply {K L M N : ModuleCat.{u} R} (f : K ⟶ L) (g : M ⟶ N) (k : K) (m : M) :
    (f ⊗ g) (k ⊗ₜ m) = f k ⊗ₜ g m 
Arguments: {R : Type u} [CommRing R] {K L M N : ModuleCat R} (f : K ⟶ L) (g : M ⟶ N) (k : ↑K) (m : ↑M)
Goal: (CategoryTheory.MonoidalCategory.tensorHom f g) (k ⊗ₜ[R] m) = f k ⊗ₜ[R] g m
-- ModuleCat.MonoidalCategory.whiskerLeft_apply
@[simp]
theorem whiskerLeft_apply (L : ModuleCat.{u} R) {M N : ModuleCat.{u} R} (f : M ⟶ N)
    (l : L) (m : M) :
    (L ◁ f) (l ⊗ₜ m) = l ⊗ₜ f m 
Arguments: {R : Type u} [CommRing R] (L : ModuleCat R) {M N : ModuleCat R} (f : M ⟶ N) (l : ↑L) (m : ↑M)
Goal: (CategoryTheory.MonoidalCategory.whiskerLeft L f) (l ⊗ₜ[R] m) = l ⊗ₜ[R] f m
-- ModuleCat.MonoidalCategory.whiskerRight_apply
@[simp]
theorem whiskerRight_apply {L M : ModuleCat.{u} R} (f : L ⟶ M) (N : ModuleCat.{u} R)
    (l : L) (n : N) :
    (f ▷ N) (l ⊗ₜ n) = f l ⊗ₜ n 
Arguments: {R : Type u} [CommRing R] {L M : ModuleCat R} (f : L ⟶ M) (N : ModuleCat R) (l : ↑L) (n : ↑N)
Goal: (CategoryTheory.MonoidalCategory.whiskerRight f N) (l ⊗ₜ[R] n) = f l ⊗ₜ[R] n
-- ModuleCat.MonoidalCategory.leftUnitor_hom_apply
@[simp]
theorem leftUnitor_hom_apply {M : ModuleCat.{u} R} (r : R) (m : M) :
    ((λ_ M).hom : 𝟙_ (ModuleCat R) ⊗ M ⟶ M) (r ⊗ₜ[R] m) = r • m 
Arguments: {R : Type u} [CommRing R] {M : ModuleCat R} (r : R) (m : ↑M)
Goal: (CategoryTheory.MonoidalCategory.leftUnitor M).hom (r ⊗ₜ[R] m) = r • m
-- ModuleCat.MonoidalCategory.leftUnitor_inv_apply
@[simp]
theorem leftUnitor_inv_apply {M : ModuleCat.{u} R} (m : M) :
    ((λ_ M).inv : M ⟶ 𝟙_ (ModuleCat.{u} R) ⊗ M) m = 1 ⊗ₜ[R] m 
Arguments: {R : Type u} [CommRing R] {M : ModuleCat R} (m : ↑M)
Goal: (CategoryTheory.MonoidalCategory.leftUnitor M).inv m = 1 ⊗ₜ[R] m
-- ModuleCat.MonoidalCategory.rightUnitor_hom_apply
@[simp]
theorem rightUnitor_hom_apply {M : ModuleCat.{u} R} (m : M) (r : R) :
    ((ρ_ M).hom : M ⊗ 𝟙_ (ModuleCat R) ⟶ M) (m ⊗ₜ r) = r • m 
Arguments: {R : Type u} [CommRing R] {M : ModuleCat R} (m : ↑M) (r : R)
Goal: (CategoryTheory.MonoidalCategory.rightUnitor M).hom (m ⊗ₜ[R] r) = r • m
-- ModuleCat.MonoidalCategory.rightUnitor_inv_apply
@[simp]
theorem rightUnitor_inv_apply {M : ModuleCat.{u} R} (m : M) :
    ((ρ_ M).inv : M ⟶ M ⊗ 𝟙_ (ModuleCat.{u} R)) m = m ⊗ₜ[R] 1 
Arguments: {R : Type u} [CommRing R] {M : ModuleCat R} (m : ↑M)
Goal: (CategoryTheory.MonoidalCategory.rightUnitor M).inv m = m ⊗ₜ[R] 1
-- ModuleCat.MonoidalCategory.associator_hom_apply
@[simp]
theorem associator_hom_apply {M N K : ModuleCat.{u} R} (m : M) (n : N) (k : K) :
    ((α_ M N K).hom : (M ⊗ N) ⊗ K ⟶ M ⊗ N ⊗ K) (m ⊗ₜ n ⊗ₜ k) = m ⊗ₜ (n ⊗ₜ k) 
Arguments: {R : Type u} [CommRing R] {M N K : ModuleCat R} (m : ↑M) (n : ↑N) (k : ↑K)
Goal: (CategoryTheory.MonoidalCategory.associator M N K).hom ((m ⊗ₜ[R] n) ⊗ₜ[R] k) = m ⊗ₜ[R] n ⊗ₜ[R] k
-- ModuleCat.MonoidalCategory.associator_inv_apply
@[simp]
theorem associator_inv_apply {M N K : ModuleCat.{u} R} (m : M) (n : N) (k : K) :
    ((α_ M N K).inv : M ⊗ N ⊗ K ⟶ (M ⊗ N) ⊗ K) (m ⊗ₜ (n ⊗ₜ k)) = m ⊗ₜ n ⊗ₜ k 
Arguments: {R : Type u} [CommRing R] {M N K : ModuleCat R} (m : ↑M) (n : ↑N) (k : ↑K)
Goal: (CategoryTheory.MonoidalCategory.associator M N K).inv (m ⊗ₜ[R] n ⊗ₜ[R] k) = (m ⊗ₜ[R] n) ⊗ₜ[R] k
-- ModuleCat.disjoint_span_sum
theorem disjoint_span_sum : Disjoint (span R (range (u ∘ Sum.inl)))
    (span R (range (u ∘ Sum.inr))) 
Arguments: {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} [Ring R] {S : CategoryTheory.ShortComplex (ModuleCat R)} (hS : S.Exact) {v : ι → ↑S.X₁} {u : ι ⊕ ι' → ↑S.X₂} (hw : LinearIndependent R (⇑S.g ∘ u ∘ Sum.inr)) (huv : u ∘ Sum.inl = ⇑S.f ∘ v)
Goal: Disjoint (Submodule.span R (Set.range (u ∘ Sum.inl))) (Submodule.span R (Set.range (u ∘ Sum.inr)))
-- ModuleCat.linearIndependent_leftExact
theorem linearIndependent_leftExact : LinearIndependent R u 
Arguments: {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} [Ring R] {S : CategoryTheory.ShortComplex (ModuleCat R)} (hS : S.Exact) {v : ι → ↑S.X₁} (hv : LinearIndependent R v) {u : ι ⊕ ι' → ↑S.X₂} (hw : LinearIndependent R (⇑S.g ∘ u ∘ Sum.inr)) (hm : CategoryTheory.Mono S.f) (huv : u ∘ Sum.inl = ⇑S.f ∘ v)
Goal: LinearIndependent R u
-- ModuleCat.linearIndependent_shortExact
theorem linearIndependent_shortExact {w : ι' → S.X₃} (hw : LinearIndependent R w) :
    LinearIndependent R (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.ShortExact) {v : ι → ↑S.X₁} (hv : LinearIndependent R v) {w : ι' → ↑S.X₃} (hw : LinearIndependent R w)
Goal: LinearIndependent R (Sum.elim (⇑S.f ∘ v) (Function.invFun S.g.toFun ∘ w))
-- ModuleCat.span_exact
theorem span_exact {β : Type*} {u : ι ⊕ β → S.X₂} (huv : u ∘ Sum.inl = S.f ∘ v)
    (hv : ⊤ ≤ span R (range v))
    (hw : ⊤ ≤ span R (range (S.g ∘ u ∘ Sum.inr))) :
    ⊤ ≤ span R (range u) 
Arguments: {ι : Type u_1} {R : Type u_3} [Ring R] {S : CategoryTheory.ShortComplex (ModuleCat R)} (hS : S.Exact) {v : ι → ↑S.X₁} {β : Type u_4} {u : ι ⊕ β → ↑S.X₂} (huv : u ∘ Sum.inl = ⇑S.f ∘ v) (hv : ⊤ ≤ Submodule.span R (Set.range v)) (hw : ⊤ ≤ Submodule.span R (Set.range (⇑S.g ∘ u ∘ Sum.inr)))
Goal: ⊤ ≤ Submodule.span R (Set.range u)