ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Algebra/Category/ModuleCat/Sheaf/Free.lean

full_name: SheafOfModules.free
code: /-- The free sheaf of modules on a certain type `I`. -/
noncomputable def free (I : Type u) : SheafOfModules.{u} R 
goal: SheafOfModules R

full_name: SheafOfModules.freeHomEquiv
code: /-- The data of a morphism `free I ⟶ M` from a free sheaf of modules is
equivalent to the data of a family `I → M.sections` of sections of `M`. -/
noncomputable def freeHomEquiv (M : SheafOfModules.{u} R) {I : Type u} :
    (free I ⟶ M) ≃ (I → M.sections) 
goal: (SheafOfModules.free I ⟶ M) ≃ (I → M.sections)

full_name: SheafOfModules.freeHomEquiv_comp_apply
code: lemma freeHomEquiv_comp_apply {M N : SheafOfModules.{u} R} {I : Type u}
    (f : free I ⟶ M) (p : M ⟶ N) (i : I) :
    N.freeHomEquiv (f ≫ p) i = sectionsMap p (M.freeHomEquiv f i) 
goal: N.freeHomEquiv (f ≫ p) i = SheafOfModules.sectionsMap p (M.freeHomEquiv f i)

full_name: SheafOfModules.freeHomEquiv_symm_comp
code: lemma freeHomEquiv_symm_comp {M N : SheafOfModules.{u} R} {I : Type u} (s : I → M.sections)
    (p : M ⟶ N) :
    M.freeHomEquiv.symm s ≫ p = N.freeHomEquiv.symm (fun i ↦ sectionsMap p (s i)) 
goal: M.freeHomEquiv.symm s ≫ p = N.freeHomEquiv.symm fun i => SheafOfModules.sectionsMap p (s i)

full_name: SheafOfModules.freeSection
code: /-- The tautological section of `free I : SheafOfModules R` corresponding to `i : I`. -/
noncomputable abbrev freeSection {I : Type u} (i : I) : (free (R := R) I).sections 
goal: (SheafOfModules.free I).sections

full_name: SheafOfModules.freeMap
code: /-- The morphism of presheaves of `R`-modules `free I ⟶ free J` induced by
a map `f : I → J`. -/
noncomputable def freeMap : free (R := R) I ⟶ free J 
goal: {J_1 : Type u} → (I → J_1) → (SheafOfModules.free I ⟶ SheafOfModules.free J_1)

full_name: SheafOfModules.freeHomEquiv_freeMap
code: @[simp]
lemma freeHomEquiv_freeMap :
    (freeHomEquiv _ (freeMap (R := R) f)) = freeSection.comp f 
goal: ∀ {J_1 : Type u} (f : I → J_1),
  (SheafOfModules.free J_1).freeHomEquiv (SheafOfModules.freeMap f) = SheafOfModules.freeSection ∘ f

full_name: SheafOfModules.sectionMap_freeMap_freeSection
code: @[simp]
lemma sectionMap_freeMap_freeSection (i : I) :
    sectionsMap (freeMap (R := R) f) (freeSection i) = freeSection (f i) 
goal: ∀ {J_1 : Type u} (f : I → J_1) (i : I),
  SheafOfModules.sectionsMap (SheafOfModules.freeMap f) (SheafOfModules.freeSection i) =
    SheafOfModules.freeSection (f i)

full_name: SheafOfModules.freeFunctor
code: /-- The functor `Type u ⥤ SheafOfModules.{u} R` which sends a type `I` to
`free I` which is a coproduct indexed by `I` of copies of `R` (thought as a
presheaf of modules over itself). --/
noncomputable def freeFunctor : Type u ⥤ SheafOfModules.{u} R 
goal: Type u ⥤ SheafOfModules R
File: Mathlib/Algebra/Category/ModuleCat/Images.lean

full_name: ModuleCat.image
code: /-- The image of a morphism in `ModuleCat R` is just the bundling of `LinearMap.range f` -/
def image : ModuleCat R 
goal: ModuleCat R

full_name: ModuleCat.image.ι
code: /-- The inclusion of `image f` into the target -/
def image.ι : image f ⟶ H 
goal: ModuleCat.image f ⟶ H

full_name: ModuleCat.instMonoι
code: instance : Mono (image.ι f) 
goal: CategoryTheory.Mono (ModuleCat.image.ι f)

full_name: ModuleCat.factorThruImage
code: /-- The corestriction map to the image -/
def factorThruImage : G ⟶ image f 
goal: G ⟶ ModuleCat.image f

full_name: ModuleCat.image.fac
code: theorem image.fac : factorThruImage f ≫ image.ι f = f 
goal: ModuleCat.factorThruImage f ≫ ModuleCat.image.ι f = f

full_name: ModuleCat.image.lift
code: /-- The universal property for the image factorisation -/
noncomputable def image.lift (F' : MonoFactorisation f) : image f ⟶ F'.I 
goal: ModuleCat.image f ⟶ F'.I

full_name: ModuleCat.image.lift_fac
code: theorem image.lift_fac (F' : MonoFactorisation f) : image.lift F' ≫ F'.m = image.ι f 
goal: ModuleCat.image.lift F' ≫ F'.m = ModuleCat.image.ι f

full_name: ModuleCat.monoFactorisation
code: /-- The factorisation of any morphism in `ModuleCat R` through a mono. -/
def monoFactorisation : MonoFactorisation f 
goal: CategoryTheory.Limits.MonoFactorisation f

full_name: ModuleCat.isImage
code: /-- The factorisation of any morphism in `ModuleCat R` through a mono has the universal property of
the image. -/
noncomputable def isImage : IsImage (monoFactorisation f) 
goal: CategoryTheory.Limits.IsImage (ModuleCat.monoFactorisation f)

full_name: ModuleCat.imageIsoRange
code: /-- The categorical image of a morphism in `ModuleCat R` agrees with the linear algebraic range. -/
noncomputable def imageIsoRange {G H : ModuleCat.{v} R} (f : G ⟶ H) :
    Limits.image f ≅ ModuleCat.of R (LinearMap.range f) 
goal: CategoryTheory.Limits.image f ≅ ModuleCat.of R ↥(LinearMap.range f)

full_name: ModuleCat.imageIsoRange_inv_image_ι
code: @[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 
goal: (ModuleCat.imageIsoRange f).inv ≫ CategoryTheory.Limits.image.ι f = ModuleCat.ofHom (LinearMap.range f).subtype

full_name: ModuleCat.imageIsoRange_hom_subtype
code: @[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 
goal: (ModuleCat.imageIsoRange f).hom ≫ ModuleCat.ofHom (LinearMap.range f).subtype = CategoryTheory.Limits.image.ι f
File: Mathlib/Algebra/Category/Ring/Adjunctions.lean

full_name: CommRingCat.free
code: /-- The free functor `Type u ⥤ CommRingCat` sending a type `X` to the multivariable (commutative)
polynomials with variables `x : X`.
-/
def free : Type u ⥤ CommRingCat.{u} 
goal: Type u ⥤ CommRingCat

full_name: CommRingCat.free_obj_coe
code: @[simp]
theorem free_obj_coe {α : Type u} : (free.obj α : Type u) = MvPolynomial α ℤ 
goal: ↑(CommRingCat.free.obj α) = MvPolynomial α ℤ

full_name: CommRingCat.free_map_coe
code: @[simp, nolint simpNF]
theorem free_map_coe {α β : Type u} {f : α → β} : ⇑(free.map f) = ⇑(rename f) 
goal: ⇑(CommRingCat.free.map f) = ⇑(MvPolynomial.rename f)

full_name: CommRingCat.adj
code: /-- The free-forgetful adjunction for commutative rings.
-/
def adj : free ⊣ forget CommRingCat.{u} 
goal: CommRingCat.free ⊣ CategoryTheory.forget CommRingCat

full_name: CommRingCat.instIsRightAdjointForget
code: instance : (forget CommRingCat.{u}).IsRightAdjoint 
goal: (CategoryTheory.forget CommRingCat).IsRightAdjoint
File: Mathlib/Algebra/Category/Ring/Instances.lean

full_name: localization_unit_isIso
code: instance localization_unit_isIso (R : CommRingCat) :
    IsIso (CommRingCat.ofHom <| algebraMap R (Localization.Away (1 : R))) 
goal: CategoryTheory.IsIso (CommRingCat.ofHom (algebraMap (↑R) (Localization.Away 1)))

full_name: localization_unit_isIso'
code: instance localization_unit_isIso' (R : CommRingCat) :
    @IsIso CommRingCat _ R _ (CommRingCat.ofHom <| algebraMap R (Localization.Away (1 : R))) 
goal: CategoryTheory.IsIso (CommRingCat.ofHom (algebraMap (↑R) (Localization.Away 1)))

full_name: IsLocalization.epi
code: 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) 
goal: CategoryTheory.Epi (CommRingCat.ofHom (algebraMap R S))

full_name: Localization.epi
code: instance Localization.epi {R : Type*} [CommRing R] (M : Submonoid R) :
    Epi (CommRingCat.ofHom <| algebraMap R <| Localization M) 
goal: CategoryTheory.Epi (CommRingCat.ofHom (algebraMap R (Localization M)))

full_name: Localization.epi'
code: instance Localization.epi' {R : CommRingCat} (M : Submonoid R) :
    @Epi CommRingCat _ R _ (CommRingCat.ofHom <| algebraMap R <| Localization M : _) 
goal: CategoryTheory.Epi (CommRingCat.ofHom (algebraMap (↑R) (Localization M)))

full_name: CommRingCat.isLocalRingHom_comp
code: instance CommRingCat.isLocalRingHom_comp {R S T : CommRingCat} (f : R ⟶ S) (g : S ⟶ T)
    [IsLocalRingHom g] [IsLocalRingHom f] : IsLocalRingHom (f ≫ g) 
goal: IsLocalRingHom (f ≫ g)

full_name: isLocalRingHom_of_iso
code: theorem isLocalRingHom_of_iso {R S : CommRingCat} (f : R ≅ S) : IsLocalRingHom f.hom 
goal: IsLocalRingHom f.hom

full_name: isLocalRingHom_of_isIso
code: instance (priority := 100) isLocalRingHom_of_isIso {R S : CommRingCat} (f : R ⟶ S) [IsIso f] :
    IsLocalRingHom f 
goal: IsLocalRingHom f
File: Mathlib/Algebra/Category/Grp/Abelian.lean

full_name: AddCommGrp.normalMono
code: /-- In the category of abelian groups, every monomorphism is normal. -/
def normalMono (_ : Mono f) : NormalMono f 
goal: CategoryTheory.Mono f → CategoryTheory.NormalMono f

full_name: AddCommGrp.normalEpi
code: /-- In the category of abelian groups, every epimorphism is normal. -/
def normalEpi (_ : Epi f) : NormalEpi f 
goal: CategoryTheory.Epi f → CategoryTheory.NormalEpi f

full_name: AddCommGrp.instAbelian
code: /-- The category of abelian groups is abelian. -/
instance : Abelian AddCommGrp.{u} 
goal: CategoryTheory.Abelian AddCommGrp
File: Mathlib/Algebra/Category/Grp/Subobject.lean

full_name: AddCommGrp.wellPowered_addCommGrp
code: instance wellPowered_addCommGrp : WellPowered AddCommGrp.{u} 
goal: CategoryTheory.WellPowered AddCommGrp
File: Mathlib/Algebra/Category/Grp/Preadditive.lean

full_name: AddCommGrp.instAddCommGroupHom
code: instance (P Q : AddCommGrp) : AddCommGroup (P ⟶ Q) 
goal: AddCommGroup (P ⟶ Q)

full_name: AddCommGrp.hom_add_apply
code: @[simp]
lemma hom_add_apply {P Q : AddCommGrp} (f g : P ⟶ Q) (x : P) : (f + g) x = f x + g x 
goal: (f + g) x = f x + g x

full_name: AddCommGrp.instPreadditive
code: instance : Preadditive AddCommGrp 
goal: CategoryTheory.Preadditive AddCommGrp
File: Mathlib/Algebra/Category/Grp/ZModuleEquivalence.lean

full_name: ModuleCat.forget₂_addCommGroup_full
code: /-- The forgetful functor from `ℤ` modules to `AddCommGrp` is full. -/
instance forget₂_addCommGroup_full : (forget₂ (ModuleCat ℤ) AddCommGrp.{u}).Full 
goal: (CategoryTheory.forget₂ (ModuleCat ℤ) AddCommGrp).Full

full_name: ModuleCat.forget₂_addCommGrp_essSurj
code: /-- The forgetful functor from `ℤ` modules to `AddCommGrp` is essentially surjective. -/
instance forget₂_addCommGrp_essSurj : (forget₂ (ModuleCat ℤ) AddCommGrp.{u}).EssSurj 
goal: (CategoryTheory.forget₂ (ModuleCat ℤ) AddCommGrp).EssSurj

full_name: ModuleCat.forget₂AddCommGroupIsEquivalence
code: noncomputable instance forget₂AddCommGroupIsEquivalence :
    (forget₂ (ModuleCat ℤ) AddCommGrp.{u}).IsEquivalence 
goal: (CategoryTheory.forget₂ (ModuleCat ℤ) AddCommGrp).IsEquivalence
File: Mathlib/Algebra/Category/Grp/Zero.lean

full_name: AddGrp.isZero_of_subsingleton
code: @[to_additive]
theorem isZero_of_subsingleton (G : Grp) [Subsingleton G] : IsZero G 
goal: CategoryTheory.Limits.IsZero G

full_name: Grp.isZero_of_subsingleton
code: @[to_additive]
theorem isZero_of_subsingleton (G : Grp) [Subsingleton G] : IsZero G 
goal: CategoryTheory.Limits.IsZero G

full_name: AddGrp.hasZeroObject
code: @[to_additive AddGrp.hasZeroObject]
instance : HasZeroObject Grp 
goal: CategoryTheory.Limits.HasZeroObject AddGrp

full_name: Grp.instHasZeroObject
code: @[to_additive AddGrp.hasZeroObject]
instance : HasZeroObject Grp 
goal: CategoryTheory.Limits.HasZeroObject Grp

full_name: CommGrp.isZero_of_subsingleton
code: @[to_additive]
theorem isZero_of_subsingleton (G : CommGrp) [Subsingleton G] : IsZero G 
goal: CategoryTheory.Limits.IsZero G

full_name: AddCommGrp.isZero_of_subsingleton
code: @[to_additive]
theorem isZero_of_subsingleton (G : CommGrp) [Subsingleton G] : IsZero G 
goal: CategoryTheory.Limits.IsZero G

full_name: CommGrp.instHasZeroObject
code: @[to_additive AddCommGrp.hasZeroObject]
instance : HasZeroObject CommGrp 
goal: CategoryTheory.Limits.HasZeroObject CommGrp

full_name: AddCommGrp.hasZeroObject
code: @[to_additive AddCommGrp.hasZeroObject]
instance : HasZeroObject CommGrp 
goal: CategoryTheory.Limits.HasZeroObject AddCommGrp
File: Mathlib/Algebra/Category/Grp/Kernels.lean

full_name: AddCommGrp.kernelCone
code: /-- The kernel cone induced by the concrete kernel. -/
def kernelCone : KernelFork f 
goal: CategoryTheory.Limits.KernelFork f

full_name: AddCommGrp.kernelIsLimit
code: /-- The kernel of a group homomorphism is a kernel in the categorical sense. -/
def kernelIsLimit : IsLimit <| kernelCone f 
goal: CategoryTheory.Limits.IsLimit (AddCommGrp.kernelCone f)

full_name: AddCommGrp.cokernelCocone
code: /-- The cokernel cocone induced by the projection onto the quotient. -/
def cokernelCocone : CokernelCofork f 
goal: CategoryTheory.Limits.CokernelCofork f

full_name: AddCommGrp.cokernelIsColimit
code: /-- The projection onto the quotient is a cokernel in the categorical sense. -/
def cokernelIsColimit : IsColimit <| cokernelCocone f 
goal: CategoryTheory.Limits.IsColimit (AddCommGrp.cokernelCocone f)
File: Mathlib/Algebra/Category/Grp/AB5.lean

full_name: instAdditiveFunctorColim
code: instance {J C : Type*} [Category J] [Category C] [HasColimitsOfShape J C] [Preadditive C] :
    (colim (J := J) (C := C)).Additive 
goal: CategoryTheory.Limits.colim.Additive

full_name: instPreservesHomologyFunctorAddCommGrpColim
code: noncomputable instance :
    (colim (J := J) (C := AddCommGrp.{u})).PreservesHomology 
goal: CategoryTheory.Limits.colim.PreservesHomology

full_name: instPreservesFiniteLimitsFunctorAddCommGrpColim
code: noncomputable instance :
    PreservesFiniteLimits <| colim (J := J) (C := AddCommGrp.{u}) 
goal: CategoryTheory.Limits.PreservesFiniteLimits CategoryTheory.Limits.colim
File: Mathlib/Algebra/Category/Grp/Injective.lean

full_name: Module.Baer.of_divisible
code: theorem Module.Baer.of_divisible [DivisibleBy A ℤ] : Module.Baer ℤ A 
goal: Module.Baer ℤ A

full_name: AddCommGrp.injective_as_module_iff
code: theorem injective_as_module_iff : Injective (⟨A⟩ : ModuleCat ℤ) ↔
    Injective (⟨A,inferInstance⟩ : AddCommGrp) 
goal: CategoryTheory.Injective (ModuleCat.mk A) ↔ CategoryTheory.Injective { α := A, str := inferInstance }

full_name: AddCommGrp.injective_of_divisible
code: instance injective_of_divisible [DivisibleBy A ℤ] :
    Injective (⟨A,inferInstance⟩ : AddCommGrp) 
goal: CategoryTheory.Injective { α := A, str := inferInstance }

full_name: AddCommGrp.injective_ratCircle
code: instance injective_ratCircle : Injective <| of <| ULift.{u} <| AddCircle (1 : ℚ) 
goal: CategoryTheory.Injective (AddCommGrp.of (ULift.{u, 0} (AddCircle 1)))
File: Mathlib/Algebra/Category/Grp/EnoughInjectives.lean

full_name: AddCommGrp.enoughInjectives
code: instance enoughInjectives : EnoughInjectives AddCommGrp.{u} 
goal: CategoryTheory.EnoughInjectives AddCommGrp

full_name: CommGrp.enoughInjectives
code: instance enoughInjectives : EnoughInjectives CommGrp.{u} 
goal: CategoryTheory.EnoughInjectives CommGrp
File: Mathlib/Algebra/Category/GrpWithZero.lean

full_name: GrpWithZero
code: /-- The category of groups with zero. -/
def GrpWithZero 
goal: Type (u_1 + 1)

full_name: GrpWithZero.instCoeSortType
code: instance : CoeSort GrpWithZero Type* 
goal: CoeSort GrpWithZero (Type u_1)

full_name: GrpWithZero.instGroupWithZeroα
code: instance (X : GrpWithZero) : GroupWithZero X 
goal: GroupWithZero ↑X

full_name: GrpWithZero.of
code: /-- Construct a bundled `GrpWithZero` from a `GroupWithZero`. -/
def of (α : Type*) [GroupWithZero α] : GrpWithZero 
goal: GrpWithZero

full_name: GrpWithZero.instInhabited
code: instance : Inhabited GrpWithZero 
goal: Inhabited GrpWithZero

full_name: GrpWithZero.instLargeCategory
code: instance : LargeCategory.{u} GrpWithZero 
goal: CategoryTheory.LargeCategory GrpWithZero

full_name: GrpWithZero.instFunLikeHomαGroupWithZero
code: instance {M N : GrpWithZero} : FunLike (M ⟶ N) M N 
goal: FunLike (M ⟶ N) ↑M ↑N

full_name: GrpWithZero.coe_id
code: lemma coe_id {X : GrpWithZero} : (𝟙 X : X → X) = id 
goal: ⇑(𝟙 X) = id

full_name: GrpWithZero.coe_comp
code: lemma coe_comp {X Y Z : GrpWithZero} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f

full_name: GrpWithZero.groupWithZeroConcreteCategory
code: instance groupWithZeroConcreteCategory : ConcreteCategory GrpWithZero 
goal: CategoryTheory.ConcreteCategory GrpWithZero

full_name: GrpWithZero.forget_map
code: @[simp] lemma forget_map {X Y : GrpWithZero} (f : X ⟶ Y) :
  (forget GrpWithZero).map f = f 
goal: (CategoryTheory.forget GrpWithZero).map f = ⇑f

full_name: GrpWithZero.hasForgetToBipointed
code: instance hasForgetToBipointed : HasForget₂ GrpWithZero Bipointed 
goal: CategoryTheory.HasForget₂ GrpWithZero Bipointed

full_name: GrpWithZero.hasForgetToMon
code: instance hasForgetToMon : HasForget₂ GrpWithZero MonCat 
goal: CategoryTheory.HasForget₂ GrpWithZero MonCat

full_name: GrpWithZero.Iso.mk_inv
code: /-- Constructs an isomorphism of groups with zero from a group isomorphism between them. -/
@[simps]
def Iso.mk {α β : GrpWithZero.{u}} (e : α ≃* β) : α ≅ β 
goal: (GrpWithZero.Iso.mk e).inv = ↑e.symm

full_name: GrpWithZero.Iso.mk
code: /-- Constructs an isomorphism of groups with zero from a group isomorphism between them. -/
@[simps]
def Iso.mk {α β : GrpWithZero.{u}} (e : α ≃* β) : α ≅ β 
goal: α ≅ β

full_name: GrpWithZero.Iso.mk_hom
code: /-- Constructs an isomorphism of groups with zero from a group isomorphism between them. -/
@[simps]
def Iso.mk {α β : GrpWithZero.{u}} (e : α ≃* β) : α ≅ β 
goal: (GrpWithZero.Iso.mk e).hom = ↑e
File: Mathlib/Algebra/Category/Grp/Images.lean

full_name: AddCommGrp.image
code: /-- the image of a morphism in `AddCommGrp` is just the bundling of `AddMonoidHom.range f` -/
def image : AddCommGrp 
goal: AddCommGrp

full_name: AddCommGrp.image.ι
code: /-- the inclusion of `image f` into the target -/
def image.ι : image f ⟶ H 
goal: AddCommGrp.image f ⟶ H

full_name: AddCommGrp.instMonoι
code: instance : Mono (image.ι f) 
goal: CategoryTheory.Mono (AddCommGrp.image.ι f)

full_name: AddCommGrp.factorThruImage
code: /-- the corestriction map to the image -/
def factorThruImage : G ⟶ image f 
goal: G ⟶ AddCommGrp.image f

full_name: AddCommGrp.image.fac
code: theorem image.fac : factorThruImage f ≫ image.ι f = f 
goal: AddCommGrp.factorThruImage f ≫ AddCommGrp.image.ι f = f

full_name: AddCommGrp.image.lift
code: /-- the universal property for the image factorisation -/
noncomputable def image.lift (F' : MonoFactorisation f) : image f ⟶ F'.I 
goal: AddCommGrp.image f ⟶ F'.I

full_name: AddCommGrp.image.lift_fac
code: theorem image.lift_fac (F' : MonoFactorisation f) : image.lift F' ≫ F'.m = image.ι f 
goal: AddCommGrp.image.lift F' ≫ F'.m = AddCommGrp.image.ι f

full_name: AddCommGrp.monoFactorisation
code: /-- the factorisation of any morphism in `AddCommGrp` through a mono. -/
def monoFactorisation : MonoFactorisation f 
goal: CategoryTheory.Limits.MonoFactorisation f

full_name: AddCommGrp.isImage
code: /-- the factorisation of any morphism in `AddCommGrp` through a mono has
the universal property of the image. -/
noncomputable def isImage : IsImage (monoFactorisation f) 
goal: CategoryTheory.Limits.IsImage (AddCommGrp.monoFactorisation f)

full_name: AddCommGrp.imageIsoRange
code: /-- The categorical image of a morphism in `AddCommGrp`
agrees with the usual group-theoretical range.
-/
noncomputable def imageIsoRange {G H : AddCommGrp.{0}} (f : G ⟶ H) :
    Limits.image f ≅ AddCommGrp.of f.range 
goal: CategoryTheory.Limits.image f ≅ AddCommGrp.of ↥(AddMonoidHom.range f)
File: Mathlib/Algebra/Category/ModuleCat/Monoidal/Closed.lean

full_name: ModuleCat.monoidalClosedHomEquiv
code: /-- Auxiliary definition for the `MonoidalClosed` instance on `Module R`.
(This is only a separate definition in order to speed up typechecking. )
-/
def monoidalClosedHomEquiv (M N P : ModuleCat.{u} R) :
    ((MonoidalCategory.tensorLeft M).obj N ⟶ P) ≃
      (N ⟶ ((linearCoyoneda R (ModuleCat R)).obj (op M)).obj P) 
goal: ((CategoryTheory.MonoidalCategory.tensorLeft M).obj N ⟶ P) ≃
  (N ⟶ ((CategoryTheory.linearCoyoneda R (ModuleCat R)).obj (Opposite.op M)).obj P)

full_name: ModuleCat.instMonoidalClosed
code: instance : MonoidalClosed (ModuleCat.{u} R) 
goal: CategoryTheory.MonoidalClosed (ModuleCat R)

full_name: ModuleCat.ihom_map_apply
code: theorem ihom_map_apply {M N P : ModuleCat.{u} R} (f : N ⟶ P) (g : ModuleCat.of R (M ⟶ N)) :
    (ihom M).map f g = g ≫ f 
goal: ((CategoryTheory.ihom M).map f) g = g ≫ f

full_name: ModuleCat.monoidalClosed_curry
code: theorem monoidalClosed_curry {M N P : ModuleCat.{u} R} (f : M ⊗ N ⟶ P) (x : M) (y : N) :
    @DFunLike.coe _ _ _ LinearMap.instFunLike
      ((MonoidalClosed.curry f : N →ₗ[R] M →ₗ[R] P) y) x = f (x ⊗ₜ[R] y) 
goal: ((CategoryTheory.MonoidalClosed.curry f) y) x = f (x ⊗ₜ[R] y)

full_name: ModuleCat.monoidalClosed_uncurry
code: @[simp]
theorem monoidalClosed_uncurry
    {M N P : ModuleCat.{u} R} (f : N ⟶ M ⟶[ModuleCat.{u} R] P) (x : M) (y : N) :
    MonoidalClosed.uncurry f (x ⊗ₜ[R] y) =
      @DFunLike.coe _ _ _ LinearMap.instFunLike (f y) x 
goal: (CategoryTheory.MonoidalClosed.uncurry f) (x ⊗ₜ[R] y) = (f y) x

full_name: ModuleCat.ihom_ev_app
code: /-- Describes the counit of the adjunction `M ⊗ - ⊣ Hom(M, -)`. Given an `R`-module `N` this
should give a map `M ⊗ Hom(M, N) ⟶ N`, so we flip the order of the arguments in the identity map
`Hom(M, N) ⟶ (M ⟶ N)` and uncurry the resulting map `M ⟶ Hom(M, N) ⟶ N.` -/
theorem ihom_ev_app (M N : ModuleCat.{u} R) :
    (ihom.ev M).app N = TensorProduct.uncurry _ _ _ _ LinearMap.id.flip 
goal: (CategoryTheory.ihom.ev M).app N = (TensorProduct.uncurry R (↑M) (↑M →ₗ[R] ↑N) ↑N) LinearMap.id.flip

full_name: ModuleCat.ihom_coev_app
code: /-- Describes the unit of the adjunction `M ⊗ - ⊣ Hom(M, -)`. Given an `R`-module `N` this should
define a map `N ⟶ Hom(M, M ⊗ N)`, which is given by flipping the arguments in the natural
`R`-bilinear map `M ⟶ N ⟶ M ⊗ N`. -/
theorem ihom_coev_app (M N : ModuleCat.{u} R) :
    (ihom.coev M).app N = (TensorProduct.mk _ _ _).flip 
goal: (CategoryTheory.ihom.coev M).app N =
  (TensorProduct.mk R ↑(Opposite.unop (Opposite.op M)) ↑((𝟭 (ModuleCat R)).obj N)).flip

full_name: ModuleCat.monoidalClosed_pre_app
code: theorem monoidalClosed_pre_app {M N : ModuleCat.{u} R} (P : ModuleCat.{u} R) (f : N ⟶ M) :
    (MonoidalClosed.pre f).app P = LinearMap.lcomp R _ f 
goal: (CategoryTheory.MonoidalClosed.pre f).app P = LinearMap.lcomp R (↑P) f