statement stringlengths 1 2.88k | proof stringlengths 0 13.9k | type stringclasses 10
values | symbolic_name stringlengths 1 131 | library stringclasses 417
values | filename stringlengths 17 80 | imports listlengths 0 16 | deps listlengths 0 64 | docstring stringlengths 0 10.2k | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
injective_of_divisible [divisible_by A ℤ] :
category_theory.injective (⟨A⟩ : AddCommGroup) | @@injective_of_injective_as_module A _ $
@@module.injective_object_of_injective_module ℤ _ A _ _ $
module.Baer.injective $
λ I g, begin
rcases is_principal_ideal_ring.principal I with ⟨m, rfl⟩,
by_cases m_eq_zero : m = 0,
{ subst m_eq_zero,
refine ⟨{ to_fun := _, map_add' := _, map_smul' := _ }, λ n hn, _⟩,
... | instance | AddCommGroup.injective_of_divisible | algebra.category.Group | src/algebra/category/Group/injective.lean | [
"algebra.category.Group.epi_mono",
"algebra.category.Module.epi_mono",
"algebra.module.injective",
"category_theory.preadditive.injective",
"group_theory.divisible",
"ring_theory.principal_ideal_domain"
] | [
"add_smul",
"algebra.id.smul_eq_mul",
"category_theory.injective",
"divisible_by",
"linear_map.coe_mk",
"module.Baer.injective",
"module.injective_object_of_injective_module",
"ring_hom.id_apply",
"set.mem_singleton",
"smul_eq_mul",
"smul_zero",
"submodule.mem_bot",
"submodule.mem_span_singl... | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
group_obj (F : J ⥤ Group.{max v u}) (j) :
group ((F ⋙ forget Group).obj j) | by { change group (F.obj j), apply_instance } | instance | Group.group_obj | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"Group",
"group"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sections_subgroup (F : J ⥤ Group) :
subgroup (Π j, F.obj j) | { carrier := (F ⋙ forget Group).sections,
inv_mem' := λ a ah j j' f,
begin
simp only [forget_map_eq_coe, functor.comp_map, pi.inv_apply, monoid_hom.map_inv, inv_inj],
dsimp [functor.sections] at ah,
rw ah f,
end,
..(Mon.sections_submonoid (F ⋙ forget₂ Group Mon)) } | def | Group.sections_subgroup | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"Group",
"Mon",
"Mon.sections_submonoid",
"inv_inj",
"monoid_hom.map_inv",
"pi.inv_apply",
"subgroup"
] | The flat sections of a functor into `Group` form a subgroup of all sections. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
limit_group (F : J ⥤ Group.{max v u}) :
group (types.limit_cone (F ⋙ forget Group)).X | begin
change group (sections_subgroup F),
apply_instance,
end | instance | Group.limit_group | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"Group",
"group"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
forget₂.creates_limit (F : J ⥤ Group.{max v u}) :
creates_limit F (forget₂ Group.{max v u} Mon.{max v u}) | creates_limit_of_reflects_iso (λ c' t,
{ lifted_cone :=
{ X := Group.of (types.limit_cone (F ⋙ forget Group)).X,
π :=
{ app := Mon.limit_π_monoid_hom (F ⋙ forget₂ Group Mon.{max v u}),
naturality' :=
(Mon.has_limits.limit_cone (F ⋙ forget₂ Group Mon.{max v u})).π.naturality, } },
valid_lift :=... | instance | Group.forget₂.creates_limit | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"Group",
"Group.of",
"Mon.has_limits.limit_cone",
"Mon.has_limits.limit_cone_is_limit",
"Mon.limit_π_monoid_hom"
] | We show that the forgetful functor `Group ⥤ Mon` creates limits.
All we need to do is notice that the limit point has a `group` instance available, and then reuse
the existing limit. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
limit_cone (F : J ⥤ Group.{max v u}) : cone F | lift_limit (limit.is_limit (F ⋙ (forget₂ Group Mon.{max v u}))) | def | Group.limit_cone | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"Group"
] | A choice of limit cone for a functor into `Group`.
(Generally, you'll just want to use `limit F`.) | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
limit_cone_is_limit (F : J ⥤ Group.{max v u}) : is_limit (limit_cone F) | lifted_limit_is_limit _ | def | Group.limit_cone_is_limit | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [] | The chosen cone is a limit cone.
(Generally, you'll just want to use `limit.cone F`.) | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
has_limits_of_size : has_limits_of_size.{v v} Group.{max v u} | { has_limits_of_shape := λ J 𝒥, by exactI
{ has_limit := λ F, has_limit_of_created F (forget₂ Group Mon.{max v u}) } } | instance | Group.has_limits_of_size | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"Group"
] | The category of groups has all limits. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
has_limits : has_limits Group.{u} | Group.has_limits_of_size.{u u} | instance | Group.has_limits | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
forget₂_Mon_preserves_limits_of_size :
preserves_limits_of_size.{v v} (forget₂ Group Mon.{max v u}) | { preserves_limits_of_shape := λ J 𝒥,
{ preserves_limit := λ F, by apply_instance } } | instance | Group.forget₂_Mon_preserves_limits_of_size | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"Group"
] | The forgetful functor from groups to monoids preserves all limits.
This means the underlying monoid of a limit can be computed as a limit in the category of monoids. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
forget₂_Mon_preserves_limits : preserves_limits (forget₂ Group Mon.{u}) | Group.forget₂_Mon_preserves_limits_of_size.{u u} | instance | Group.forget₂_Mon_preserves_limits | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"Group"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
forget_preserves_limits_of_size :
preserves_limits_of_size.{v v} (forget Group.{max v u}) | { preserves_limits_of_shape := λ J 𝒥, by exactI
{ preserves_limit := λ F, limits.comp_preserves_limit (forget₂ Group Mon) (forget Mon) } } | instance | Group.forget_preserves_limits_of_size | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"Group",
"Mon"
] | The forgetful functor from groups to types preserves all limits.
This means the underlying type of a limit can be computed as a limit in the category of types. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
forget_preserves_limits : preserves_limits (forget Group.{u}) | Group.forget_preserves_limits_of_size.{u u} | instance | Group.forget_preserves_limits | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
comm_group_obj (F : J ⥤ CommGroup.{max v u}) (j) :
comm_group ((F ⋙ forget CommGroup).obj j) | by { change comm_group (F.obj j), apply_instance } | instance | CommGroup.comm_group_obj | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"CommGroup",
"comm_group"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
limit_comm_group (F : J ⥤ CommGroup.{max v u}) :
comm_group (types.limit_cone (F ⋙ forget CommGroup.{max v u})).X | @subgroup.to_comm_group (Π j, F.obj j) _
(Group.sections_subgroup (F ⋙ forget₂ CommGroup Group.{max v u})) | instance | CommGroup.limit_comm_group | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"CommGroup",
"Group.sections_subgroup",
"comm_group",
"subgroup.to_comm_group"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
forget₂.creates_limit (F : J ⥤ CommGroup.{max v u}) :
creates_limit F (forget₂ CommGroup Group.{max v u}) | creates_limit_of_reflects_iso (λ c' t,
{ lifted_cone :=
{ X := CommGroup.of (types.limit_cone (F ⋙ forget CommGroup)).X,
π :=
{ app := Mon.limit_π_monoid_hom
(F ⋙ forget₂ CommGroup Group.{max v u} ⋙ forget₂ Group Mon.{max v u}),
naturality' := (Mon.has_limits.limit_cone _).π.naturality, } },
v... | instance | CommGroup.forget₂.creates_limit | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"CommGroup",
"CommGroup.of",
"Group",
"Group.limit_cone_is_limit",
"Mon.has_limits.limit_cone",
"Mon.has_limits.limit_cone_is_limit",
"Mon.limit_π_monoid_hom"
] | We show that the forgetful functor `CommGroup ⥤ Group` creates limits.
All we need to do is notice that the limit point has a `comm_group` instance available,
and then reuse the existing limit. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
limit_cone (F : J ⥤ CommGroup.{max v u}) : cone F | lift_limit (limit.is_limit (F ⋙ (forget₂ CommGroup Group.{max v u}))) | def | CommGroup.limit_cone | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"CommGroup"
] | A choice of limit cone for a functor into `CommGroup`.
(Generally, you'll just want to use `limit F`.) | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
limit_cone_is_limit (F : J ⥤ CommGroup.{max v u}) : is_limit (limit_cone F) | lifted_limit_is_limit _ | def | CommGroup.limit_cone_is_limit | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [] | The chosen cone is a limit cone.
(Generally, you'll just want to use `limit.cone F`.) | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
has_limits_of_size : has_limits_of_size.{v v} CommGroup.{max v u} | { has_limits_of_shape := λ J 𝒥, by exactI
{ has_limit := λ F, has_limit_of_created F (forget₂ CommGroup Group.{max v u}) } } | instance | CommGroup.has_limits_of_size | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"CommGroup"
] | The category of commutative groups has all limits. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
has_limits : has_limits CommGroup.{u} | CommGroup.has_limits_of_size.{u u} | instance | CommGroup.has_limits | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
forget₂_Group_preserves_limits_of_size :
preserves_limits_of_size.{v v} (forget₂ CommGroup Group.{max v u}) | { preserves_limits_of_shape := λ J 𝒥,
{ preserves_limit := λ F, by apply_instance } } | instance | CommGroup.forget₂_Group_preserves_limits_of_size | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"CommGroup"
] | The forgetful functor from commutative groups to groups preserves all limits.
(That is, the underlying group could have been computed instead as limits in the category
of groups.) | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
forget₂_Group_preserves_limits : preserves_limits (forget₂ CommGroup Group.{u}) | CommGroup.forget₂_Group_preserves_limits_of_size.{u u} | instance | CommGroup.forget₂_Group_preserves_limits | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"CommGroup"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
forget₂_CommMon_preserves_limits_aux (F : J ⥤ CommGroup.{max v u}) :
is_limit ((forget₂ CommGroup CommMon).map_cone (limit_cone F)) | CommMon.limit_cone_is_limit (F ⋙ forget₂ CommGroup CommMon) | def | CommGroup.forget₂_CommMon_preserves_limits_aux | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"CommGroup",
"CommMon",
"CommMon.limit_cone_is_limit"
] | An auxiliary declaration to speed up typechecking. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
forget₂_CommMon_preserves_limits_of_size :
preserves_limits_of_size.{v v} (forget₂ CommGroup CommMon.{max v u}) | { preserves_limits_of_shape := λ J 𝒥, by exactI
{ preserves_limit := λ F, preserves_limit_of_preserves_limit_cone
(limit_cone_is_limit F) (forget₂_CommMon_preserves_limits_aux F) } } | instance | CommGroup.forget₂_CommMon_preserves_limits_of_size | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"CommGroup"
] | The forgetful functor from commutative groups to commutative monoids preserves all limits.
(That is, the underlying commutative monoids could have been computed instead as limits
in the category of commutative monoids.) | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
forget_preserves_limits_of_size :
preserves_limits_of_size.{v v} (forget CommGroup.{max v u}) | { preserves_limits_of_shape := λ J 𝒥, by exactI
{ preserves_limit := λ F, limits.comp_preserves_limit (forget₂ CommGroup Group) (forget Group) } } | instance | CommGroup.forget_preserves_limits_of_size | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [
"CommGroup",
"Group"
] | The forgetful functor from commutative groups to types preserves all limits. (That is, the
underlying types could have been computed instead as limits in the category of types.) | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
kernel_iso_ker {G H : AddCommGroup.{u}} (f : G ⟶ H) :
kernel f ≅ AddCommGroup.of f.ker | { hom :=
{ to_fun := λ g, ⟨kernel.ι f g,
begin
-- TODO where is this `has_coe_t_aux.coe` coming from? can we prevent it appearing?
change (kernel.ι f) g ∈ f.ker,
simp [add_monoid_hom.mem_ker],
end⟩,
map_zero' := by { ext, simp, },
map_add' := λ g g', by { ext, simp, }, },
inv := ke... | def | AddCommGroup.kernel_iso_ker | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [] | The categorical kernel of a morphism in `AddCommGroup`
agrees with the usual group-theoretical kernel. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
kernel_iso_ker_hom_comp_subtype {G H : AddCommGroup} (f : G ⟶ H) :
(kernel_iso_ker f).hom ≫ add_subgroup.subtype f.ker = kernel.ι f | by ext; refl | lemma | AddCommGroup.kernel_iso_ker_hom_comp_subtype | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
kernel_iso_ker_inv_comp_ι {G H : AddCommGroup} (f : G ⟶ H) :
(kernel_iso_ker f).inv ≫ kernel.ι f = add_subgroup.subtype f.ker | begin
ext,
simp [kernel_iso_ker],
end | lemma | AddCommGroup.kernel_iso_ker_inv_comp_ι | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
kernel_iso_ker_over {G H : AddCommGroup.{u}} (f : G ⟶ H) :
over.mk (kernel.ι f) ≅ @over.mk _ _ G (AddCommGroup.of f.ker) (add_subgroup.subtype f.ker) | over.iso_mk (kernel_iso_ker f) (by simp) | def | AddCommGroup.kernel_iso_ker_over | algebra.category.Group | src/algebra/category/Group/limits.lean | [
"algebra.category.Mon.limits",
"algebra.category.Group.preadditive",
"category_theory.over",
"group_theory.subgroup.basic",
"category_theory.concrete_category.elementwise"
] | [] | The categorical kernel inclusion for `f : G ⟶ H`, as an object over `G`,
agrees with the `subtype` map. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
well_powered_AddCommGroup : well_powered (AddCommGroup.{u}) | well_powered_of_equiv (forget₂ (Module.{u} ℤ) AddCommGroup.{u}).as_equivalence | instance | AddCommGroup.well_powered_AddCommGroup | algebra.category.Group | src/algebra/category/Group/subobject.lean | [
"algebra.category.Group.Z_Module_equivalence",
"algebra.category.Module.subobject"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_zero_of_subsingleton (G : Group) [subsingleton G] :
is_zero G | begin
refine ⟨λ X, ⟨⟨⟨1⟩, λ f, _⟩⟩, λ X, ⟨⟨⟨1⟩, λ f, _⟩⟩⟩,
{ ext, have : x = 1 := subsingleton.elim _ _, rw [this, map_one, map_one], },
{ ext, apply subsingleton.elim }
end | lemma | Group.is_zero_of_subsingleton | algebra.category.Group | src/algebra/category/Group/zero.lean | [
"algebra.category.Group.basic",
"category_theory.limits.shapes.zero_objects"
] | [
"Group",
"map_one"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_zero_of_subsingleton (G : CommGroup) [subsingleton G] :
is_zero G | begin
refine ⟨λ X, ⟨⟨⟨1⟩, λ f, _⟩⟩, λ X, ⟨⟨⟨1⟩, λ f, _⟩⟩⟩,
{ ext, have : x = 1 := subsingleton.elim _ _, rw [this, map_one, map_one], },
{ ext, apply subsingleton.elim }
end | lemma | CommGroup.is_zero_of_subsingleton | algebra.category.Group | src/algebra/category/Group/zero.lean | [
"algebra.category.Group.basic",
"category_theory.limits.shapes.zero_objects"
] | [
"CommGroup",
"map_one"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
forget₂_AddCommGroup_full : full (forget₂ (Module ℤ) AddCommGroup.{u}) | { preimage := λ A B f,
-- `add_monoid_hom.to_int_linear_map` doesn't work here because `A` and `B` are not definitionally
-- equal to the canonical `add_comm_group.int_module` module instances it expects.
{ to_fun := f,
map_add' := add_monoid_hom.map_add f,
map_smul' := λ n x, by rw [int_smul_eq_zsmul, in... | instance | Module.forget₂_AddCommGroup_full | algebra.category.Group | src/algebra/category/Group/Z_Module_equivalence.lean | [
"algebra.category.Module.basic"
] | [
"Module",
"int_smul_eq_zsmul",
"map_zsmul",
"ring_hom.id_apply"
] | The forgetful functor from `ℤ` modules to `AddCommGroup` is full. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
forget₂_AddCommGroup_ess_surj : ess_surj (forget₂ (Module ℤ) AddCommGroup.{u}) | { mem_ess_image := λ A, ⟨Module.of ℤ A, ⟨{ hom := 𝟙 A, inv := 𝟙 A }⟩⟩} | instance | Module.forget₂_AddCommGroup_ess_surj | algebra.category.Group | src/algebra/category/Group/Z_Module_equivalence.lean | [
"algebra.category.Module.basic"
] | [
"Module"
] | The forgetful functor from `ℤ` modules to `AddCommGroup` is essentially surjective. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
forget₂_AddCommGroup_is_equivalence :
is_equivalence (forget₂ (Module ℤ) AddCommGroup.{u}) | equivalence.of_fully_faithfully_ess_surj (forget₂ (Module ℤ) AddCommGroup) | instance | Module.forget₂_AddCommGroup_is_equivalence | algebra.category.Group | src/algebra/category/Group/Z_Module_equivalence.lean | [
"algebra.category.Module.basic"
] | [
"Module"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
normal_mono (hf : mono f) : normal_mono f | { Z := of R (N ⧸ f.range),
g := f.range.mkq,
w := linear_map.range_mkq_comp _,
is_limit :=
is_kernel.iso_kernel _ _ (kernel_is_limit _)
/- The following [invalid Lean code](https://github.com/leanprover-community/lean/issues/341)
might help you understand what's going on here:
```
... | def | Module.normal_mono | algebra.category.Module | src/algebra/category/Module/abelian.lean | [
"linear_algebra.isomorphisms",
"algebra.category.Module.kernels",
"algebra.category.Module.limits",
"category_theory.abelian.exact"
] | [
"linear_equiv.of_eq",
"linear_equiv.to_Module_iso'",
"linear_map.quot_ker_equiv_range",
"linear_map.range_mkq_comp",
"submodule.ker_mkq",
"submodule.quot_equiv_of_eq_bot"
] | In the category of modules, every monomorphism is normal. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
normal_epi (hf : epi f) : normal_epi f | { W := of R f.ker,
g := f.ker.subtype,
w := linear_map.comp_ker_subtype _,
is_colimit :=
is_cokernel.cokernel_iso _ _ (cokernel_is_colimit _)
(linear_equiv.to_Module_iso'
/- The following invalid Lean code might help you understand what's going on here:
```
calc f.ker.subtype.range... | def | Module.normal_epi | algebra.category.Module | src/algebra/category/Module/abelian.lean | [
"linear_algebra.isomorphisms",
"algebra.category.Module.kernels",
"algebra.category.Module.limits",
"category_theory.abelian.exact"
] | [
"linear_equiv.of_top",
"linear_equiv.to_Module_iso'",
"linear_map.comp_ker_subtype",
"linear_map.quot_ker_equiv_range",
"submodule.quot_equiv_of_eq",
"submodule.range_subtype"
] | In the category of modules, every epimorphism is normal. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
abelian : abelian (Module R) | { has_finite_products := ⟨λ n, limits.has_limits_of_shape_of_has_limits⟩,
has_kernels := limits.has_kernels_of_has_equalizers (Module R),
has_cokernels := has_cokernels_Module,
normal_mono_of_mono := λ X Y, normal_mono,
normal_epi_of_epi := λ X Y, normal_epi } | instance | Module.abelian | algebra.category.Module | src/algebra/category/Module/abelian.lean | [
"linear_algebra.isomorphisms",
"algebra.category.Module.kernels",
"algebra.category.Module.limits",
"category_theory.abelian.exact"
] | [
"Module"
] | The category of R-modules is abelian. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
forget_reflects_limits_of_size :
reflects_limits_of_size.{v v} (forget (Module.{max v w} R)) | reflects_limits_of_reflects_isomorphisms | instance | Module.forget_reflects_limits_of_size | algebra.category.Module | src/algebra/category/Module/abelian.lean | [
"linear_algebra.isomorphisms",
"algebra.category.Module.kernels",
"algebra.category.Module.limits",
"category_theory.abelian.exact"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
forget₂_reflects_limits_of_size :
reflects_limits_of_size.{v v} (forget₂ (Module.{max v w} R) AddCommGroup.{max v w}) | reflects_limits_of_reflects_isomorphisms | instance | Module.forget₂_reflects_limits_of_size | algebra.category.Module | src/algebra/category/Module/abelian.lean | [
"linear_algebra.isomorphisms",
"algebra.category.Module.kernels",
"algebra.category.Module.limits",
"category_theory.abelian.exact"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
forget_reflects_limits : reflects_limits (forget (Module.{v} R)) | Module.forget_reflects_limits_of_size.{v v} | instance | Module.forget_reflects_limits | algebra.category.Module | src/algebra/category/Module/abelian.lean | [
"linear_algebra.isomorphisms",
"algebra.category.Module.kernels",
"algebra.category.Module.limits",
"category_theory.abelian.exact"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
forget₂_reflects_limits : reflects_limits (forget₂ (Module.{v} R) AddCommGroup.{v}) | Module.forget₂_reflects_limits_of_size.{v v} | instance | Module.forget₂_reflects_limits | algebra.category.Module | src/algebra/category/Module/abelian.lean | [
"linear_algebra.isomorphisms",
"algebra.category.Module.kernels",
"algebra.category.Module.limits",
"category_theory.abelian.exact"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
exact_iff : exact f g ↔ f.range = g.ker | begin
rw abelian.exact_iff' f g (kernel_is_limit _) (cokernel_is_colimit _),
exact ⟨λ h, le_antisymm (range_le_ker_iff.2 h.1) (ker_le_range_iff.2 h.2),
λ h, ⟨range_le_ker_iff.1 $ le_of_eq h, ker_le_range_iff.1 $ le_of_eq h.symm⟩⟩
end | theorem | Module.exact_iff | algebra.category.Module | src/algebra/category/Module/abelian.lean | [
"linear_algebra.isomorphisms",
"algebra.category.Module.kernels",
"algebra.category.Module.limits",
"category_theory.abelian.exact"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
free : Type u ⥤ Module R | { obj := λ X, Module.of R (X →₀ R),
map := λ X Y f, finsupp.lmap_domain _ _ f,
map_id' := by { intros, exact finsupp.lmap_domain_id _ _ },
map_comp' := by { intros, exact finsupp.lmap_domain_comp _ _ _ _, } } | def | Module.free | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"Module",
"Module.of",
"finsupp.lmap_domain",
"finsupp.lmap_domain_comp",
"finsupp.lmap_domain_id",
"free"
] | The free functor `Type u ⥤ Module R` sending a type `X` to the
free `R`-module with generators `x : X`, implemented as the type `X →₀ R`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
adj : free R ⊣ forget (Module.{u} R) | adjunction.mk_of_hom_equiv
{ hom_equiv := λ X M, (finsupp.lift M R X).to_equiv.symm,
hom_equiv_naturality_left_symm' := λ _ _ M f g,
finsupp.lhom_ext' (λ x, linear_map.ext_ring
(finsupp.sum_map_domain_index_add_monoid_hom (λ y, ((smul_add_hom R M).flip) (g y))).symm) } | def | Module.adj | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"adj",
"finsupp.lhom_ext'",
"finsupp.lift",
"finsupp.sum_map_domain_index_add_monoid_hom",
"free",
"linear_map.ext_ring",
"smul_add_hom"
] | The free-forgetful adjunction for R-modules. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
ε : 𝟙_ (Module.{u} R) ⟶ (free R).obj (𝟙_ (Type u)) | finsupp.lsingle punit.star | def | Module.free.ε | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"finsupp.lsingle",
"free"
] | (Implementation detail) The unitor for `free R`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
ε_apply (r : R) : ε R r = finsupp.single punit.star r | rfl | lemma | Module.free.ε_apply | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"finsupp.single"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
μ (α β : Type u) : (free R).obj α ⊗ (free R).obj β ≅ (free R).obj (α ⊗ β) | (finsupp_tensor_finsupp' R α β).to_Module_iso | def | Module.free.μ | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"finsupp_tensor_finsupp'",
"free"
] | (Implementation detail) The tensorator for `free R`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
μ_natural {X Y X' Y' : Type u} (f : X ⟶ Y) (g : X' ⟶ Y') :
((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom =
(μ R X X').hom ≫ (free R).map (f ⊗ g) | begin
intros,
ext x x' ⟨y, y'⟩,
dsimp [μ],
simp_rw [finsupp.map_domain_single, finsupp_tensor_finsupp'_single_tmul_single, mul_one,
finsupp.map_domain_single, category_theory.tensor_apply],
end | lemma | Module.free.μ_natural | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"category_theory.tensor_apply",
"finsupp.map_domain_single",
"finsupp_tensor_finsupp'_single_tmul_single",
"free",
"mul_one"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
left_unitality (X : Type u) :
(λ_ ((free R).obj X)).hom =
(ε R ⊗ 𝟙 ((free R).obj X)) ≫ (μ R (𝟙_ (Type u)) X).hom ≫ map (free R).obj (λ_ X).hom | begin
intros,
ext,
dsimp [ε, μ],
simp_rw [finsupp_tensor_finsupp'_single_tmul_single,
Module.monoidal_category.left_unitor_hom_apply, finsupp.smul_single', mul_one,
finsupp.map_domain_single, category_theory.left_unitor_hom_apply],
end | lemma | Module.free.left_unitality | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"Module.monoidal_category.left_unitor_hom_apply",
"category_theory.left_unitor_hom_apply",
"finsupp.map_domain_single",
"finsupp.smul_single'",
"finsupp_tensor_finsupp'_single_tmul_single",
"free",
"mul_one"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
right_unitality (X : Type u) :
(ρ_ ((free R).obj X)).hom =
(𝟙 ((free R).obj X) ⊗ ε R) ≫ (μ R X (𝟙_ (Type u))).hom ≫ map (free R).obj (ρ_ X).hom | begin
intros,
ext,
dsimp [ε, μ],
simp_rw [finsupp_tensor_finsupp'_single_tmul_single,
Module.monoidal_category.right_unitor_hom_apply, finsupp.smul_single', mul_one,
finsupp.map_domain_single, category_theory.right_unitor_hom_apply],
end | lemma | Module.free.right_unitality | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"Module.monoidal_category.right_unitor_hom_apply",
"category_theory.right_unitor_hom_apply",
"finsupp.map_domain_single",
"finsupp.smul_single'",
"finsupp_tensor_finsupp'_single_tmul_single",
"free",
"mul_one"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
associativity (X Y Z : Type u) :
((μ R X Y).hom ⊗ 𝟙 ((free R).obj Z)) ≫ (μ R (X ⊗ Y) Z).hom ≫ map (free R).obj (α_ X Y Z).hom =
(α_ ((free R).obj X) ((free R).obj Y) ((free R).obj Z)).hom ≫
(𝟙 ((free R).obj X) ⊗ (μ R Y Z).hom) ≫ (μ R X (Y ⊗ Z)).hom | begin
intros,
ext,
dsimp [μ],
simp_rw [finsupp_tensor_finsupp'_single_tmul_single, finsupp.map_domain_single, mul_one,
category_theory.associator_hom_apply],
end | lemma | Module.free.associativity | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"category_theory.associator_hom_apply",
"finsupp.map_domain_single",
"finsupp_tensor_finsupp'_single_tmul_single",
"free",
"mul_one"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
monoidal_free : monoidal_functor (Type u) (Module.{u} R) | { ε_is_iso := by { dsimp, apply_instance, },
μ_is_iso := λ X Y, by { dsimp, apply_instance, },
..lax_monoidal_functor.of (free R).obj } | def | Module.monoidal_free | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"free"
] | The free functor `Type u ⥤ Module R`, as a monoidal functor. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
Free (R : Type*) (C : Type u) | C | def | category_theory.Free | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [] | `Free R C` is a type synonym for `C`, which, given `[comm_ring R]` and `[category C]`,
we will equip with a category structure where the morphisms are formal `R`-linear combinations
of the morphisms in `C`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
Free.of (R : Type*) {C : Type u} (X : C) : Free R C | X | def | category_theory.Free.of | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [] | Consider an object of `C` as an object of the `R`-linear completion.
It may be preferable to use `(Free.embedding R C).obj X` instead;
this functor can also be used to lift morphisms. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
category_Free : category (Free R C) | { hom := λ (X Y : C), (X ⟶ Y) →₀ R,
id := λ (X : C), finsupp.single (𝟙 X) 1,
comp := λ (X Y Z : C) f g, f.sum (λ f' s, g.sum (λ g' t, finsupp.single (f' ≫ g') (s * t))),
assoc' := λ W X Y Z f g h,
begin
dsimp,
-- This imitates the proof of associativity for `monoid_algebra`.
simp only [sum_sum_inde... | instance | category_theory.category_Free | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"finsupp.single",
"forall_3_true_iff",
"forall_true_iff",
"mul_assoc",
"mul_zero",
"zero_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_comp_single {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (r s : R) :
(single f r ≫ single g s : (Free.of R X) ⟶ (Free.of R Z)) = single (f ≫ g) (r * s) | by { dsimp, simp, } | lemma | category_theory.Free.single_comp_single | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
embedding : C ⥤ Free R C | { obj := λ X, X,
map := λ X Y f, finsupp.single f 1,
map_id' := λ X, rfl,
map_comp' := λ X Y Z f g, by simp, } | def | category_theory.Free.embedding | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"embedding",
"finsupp.single"
] | A category embeds into its `R`-linear completion. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
lift (F : C ⥤ D) : Free R C ⥤ D | { obj := λ X, F.obj X,
map := λ X Y f, f.sum (λ f' r, r • (F.map f')),
map_id' := by { dsimp [category_theory.category_Free], simp },
map_comp' := λ X Y Z f g, begin
apply finsupp.induction_linear f,
{ simp only [limits.zero_comp, sum_zero_index] },
{ intros f₁ f₂ w₁ w₂,
rw add_comp,
rw [f... | def | category_theory.Free.lift | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"add_smul",
"category_theory.category_Free",
"finsupp.induction_linear",
"lift",
"mul_comm",
"zero_smul"
] | A functor to an `R`-linear category lifts to a functor from its `R`-linear completion. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
lift_map_single (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) (r : R) :
(lift R F).map (single f r) = r • F.map f | by simp | lemma | category_theory.Free.lift_map_single | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"lift"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_additive (F : C ⥤ D) : (lift R F).additive | { map_add' := λ X Y f g, begin
dsimp,
rw finsupp.sum_add_index'; simp [add_smul]
end, } | instance | category_theory.Free.lift_additive | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"add_smul",
"additive",
"lift"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_linear (F : C ⥤ D) : (lift R F).linear R | { map_smul' := λ X Y f r, begin
dsimp,
rw finsupp.sum_smul_index;
simp [finsupp.smul_sum, mul_smul],
end, } | instance | category_theory.Free.lift_linear | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"finsupp.smul_sum",
"finsupp.sum_smul_index",
"lift"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
embedding_lift_iso (F : C ⥤ D) : embedding R C ⋙ lift R F ≅ F | nat_iso.of_components
(λ X, iso.refl _)
(by tidy) | def | category_theory.Free.embedding_lift_iso | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"embedding",
"lift"
] | The embedding into the `R`-linear completion, followed by the lift,
is isomorphic to the original functor. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
ext {F G : Free R C ⥤ D} [F.additive] [F.linear R] [G.additive] [G.linear R]
(α : embedding R C ⋙ F ≅ embedding R C ⋙ G) : F ≅ G | nat_iso.of_components
(λ X, α.app X)
begin
intros X Y f,
apply finsupp.induction_linear f,
{ simp, },
{ intros f₁ f₂ w₁ w₂,
simp only [F.map_add, G.map_add, add_comp, comp_add, w₁, w₂], },
{ intros f' r,
rw [iso.app_hom, iso.app_hom, ←smul_single_one, F.map_smul, G.map_smul, smul_com... | def | category_theory.Free.ext | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"embedding",
"finsupp.induction_linear"
] | Two `R`-linear functors out of the `R`-linear completion are isomorphic iff their
compositions with the embedding functor are isomorphic. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
lift_unique (F : C ⥤ D) (L : Free R C ⥤ D) [L.additive] [L.linear R]
(α : embedding R C ⋙ L ≅ F) :
L ≅ lift R F | ext R (α.trans (embedding_lift_iso R F).symm) | def | category_theory.Free.lift_unique | algebra.category.Module | src/algebra/category/Module/adjunctions.lean | [
"algebra.category.Module.monoidal.basic",
"category_theory.monoidal.functorial",
"category_theory.monoidal.types.basic",
"linear_algebra.direct_sum.finsupp",
"category_theory.linear.linear_functor"
] | [
"embedding",
"lift",
"lift_unique"
] | `Free.lift` is unique amongst `R`-linear functors `Free R C ⥤ D`
which compose with `embedding ℤ C` to give the original functor. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
module_of_algebra_Module (M : Module.{v} A) : module k M | restrict_scalars.module k A M | def | Module.module_of_algebra_Module | algebra.category.Module | src/algebra/category/Module/algebra.lean | [
"algebra.algebra.restrict_scalars",
"category_theory.linear.basic",
"algebra.category.Module.basic"
] | [
"module"
] | Type synonym for considering a module over a `k`-algebra as a `k`-module. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
is_scalar_tower_of_algebra_Module (M : Module.{v} A) : is_scalar_tower k A M | restrict_scalars.is_scalar_tower k A M | lemma | Module.is_scalar_tower_of_algebra_Module | algebra.category.Module | src/algebra/category/Module/algebra.lean | [
"algebra.algebra.restrict_scalars",
"category_theory.linear.basic",
"algebra.category.Module.basic"
] | [
"is_scalar_tower"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
linear_over_field : linear k (Module.{v} A) | { hom_module := λ M N, by apply_instance, } | instance | Module.linear_over_field | algebra.category.Module | src/algebra/category/Module/algebra.lean | [
"algebra.algebra.restrict_scalars",
"category_theory.linear.basic",
"algebra.category.Module.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
Module | (carrier : Type v)
[is_add_comm_group : add_comm_group carrier]
[is_module : module R carrier] | structure | Module | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"add_comm_group",
"module"
] | The category of R-modules and their morphisms.
Note that in the case of `R = ℤ`, we can not
impose here that the `ℤ`-multiplication field from the module structure is defeq to the one coming
from the `is_add_comm_group` structure (contrary to what we do for all module structures in
mathlib), which creates some diffic... | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
Module_category : category (Module.{v} R) | { hom := λ M N, M →ₗ[R] N,
id := λ M, 1,
comp := λ A B C f g, g.comp f,
id_comp' := λ X Y f, linear_map.id_comp _,
comp_id' := λ X Y f, linear_map.comp_id _,
assoc' := λ W X Y Z f g h, linear_map.comp_assoc _ _ _ } | instance | Module.Module_category | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"linear_map.comp_assoc",
"linear_map.comp_id",
"linear_map.id_comp"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
Module_concrete_category : concrete_category.{v} (Module.{v} R) | { forget := { obj := λ R, R, map := λ R S f, (f : R → S) },
forget_faithful := { } } | instance | Module.Module_concrete_category | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
has_forget_to_AddCommGroup : has_forget₂ (Module R) AddCommGroup | { forget₂ :=
{ obj := λ M, AddCommGroup.of M,
map := λ M₁ M₂ f, linear_map.to_add_monoid_hom f } } | instance | Module.has_forget_to_AddCommGroup | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"Module",
"linear_map.to_add_monoid_hom"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of (X : Type v) [add_comm_group X] [module R X] : Module R | ⟨X⟩ | def | Module.of | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"Module",
"add_comm_group",
"module"
] | The object in the category of R-modules associated to an R-module | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
forget₂_obj (X : Module R) :
(forget₂ (Module R) AddCommGroup).obj X = AddCommGroup.of X | rfl | lemma | Module.forget₂_obj | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"Module"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
forget₂_obj_Module_of (X : Type v) [add_comm_group X] [module R X] :
(forget₂ (Module R) AddCommGroup).obj (of R X) = AddCommGroup.of X | rfl | lemma | Module.forget₂_obj_Module_of | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"Module",
"add_comm_group",
"module"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
forget₂_map (X Y : Module R) (f : X ⟶ Y) :
(forget₂ (Module R) AddCommGroup).map f = linear_map.to_add_monoid_hom f | rfl | lemma | Module.forget₂_map | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"Module",
"linear_map.to_add_monoid_hom"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of_hom {R : Type u} [ring R] {X Y : Type v} [add_comm_group X] [module R X] [add_comm_group Y]
[module R Y] (f : X →ₗ[R] Y) : of R X ⟶ of R Y | f | def | Module.of_hom | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"add_comm_group",
"module",
"ring"
] | Typecheck a `linear_map` as a morphism in `Module R`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
of_hom_apply {R : Type u} [ring R]
{X Y : Type v} [add_comm_group X] [module R X] [add_comm_group Y] [module R Y] (f : X →ₗ[R] Y)
(x : X) : of_hom f x = f x | rfl | lemma | Module.of_hom_apply | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"add_comm_group",
"module",
"ring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of_unique {X : Type v} [add_comm_group X] [module R X] [i : unique X] :
unique (of R X) | i | instance | Module.of_unique | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"add_comm_group",
"module",
"unique"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_of (X : Type v) [add_comm_group X] [module R X] : (of R X : Type v) = X | rfl | lemma | Module.coe_of | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"add_comm_group",
"module"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of_self_iso (M : Module R) : Module.of R M ≅ M | { hom := 𝟙 M, inv := 𝟙 M } | def | Module.of_self_iso | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"Module",
"Module.of"
] | Forgetting to the underlying type and then building the bundled object returns the original
module. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
is_zero_of_subsingleton (M : Module R) [subsingleton M] :
is_zero M | begin
refine ⟨λ X, ⟨⟨⟨0⟩, λ f, _⟩⟩, λ X, ⟨⟨⟨0⟩, λ f, _⟩⟩⟩,
{ ext, have : x = 0 := subsingleton.elim _ _, rw [this, map_zero, map_zero], },
{ ext, apply subsingleton.elim }
end | lemma | Module.is_zero_of_subsingleton | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"Module"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
comp_def (f : M ⟶ N) (g : N ⟶ U) : f ≫ g = g.comp f | rfl | lemma | Module.comp_def | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
Module.as_hom [add_comm_group X₁] [module R X₁] [add_comm_group X₂] [module R X₂] :
(X₁ →ₗ[R] X₂) → (Module.of R X₁ ⟶ Module.of R X₂) | id | def | Module.as_hom | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"Module.of",
"add_comm_group",
"module"
] | Reinterpreting a linear map in the category of `R`-modules. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
Module.as_hom_right [add_comm_group X₁] [module R X₁] {X₂ : Module.{v} R} :
(X₁ →ₗ[R] X₂) → (Module.of R X₁ ⟶ X₂) | id | def | Module.as_hom_right | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"Module.of",
"add_comm_group",
"module"
] | Reinterpreting a linear map in the category of `R`-modules. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
Module.as_hom_left {X₁ : Module.{v} R} [add_comm_group X₂] [module R X₂] :
(X₁ →ₗ[R] X₂) → (X₁ ⟶ Module.of R X₂) | id | def | Module.as_hom_left | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"Module.of",
"add_comm_group",
"module"
] | Reinterpreting a linear map in the category of `R`-modules. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
linear_equiv.to_Module_iso
{g₁ : add_comm_group X₁} {g₂ : add_comm_group X₂} {m₁ : module R X₁} {m₂ : module R X₂}
(e : X₁ ≃ₗ[R] X₂) :
Module.of R X₁ ≅ Module.of R X₂ | { hom := (e : X₁ →ₗ[R] X₂),
inv := (e.symm : X₂ →ₗ[R] X₁),
hom_inv_id' := begin ext, exact e.left_inv x, end,
inv_hom_id' := begin ext, exact e.right_inv x, end, } | def | linear_equiv.to_Module_iso | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"Module.of",
"add_comm_group",
"module"
] | Build an isomorphism in the category `Module R` from a `linear_equiv` between `module`s. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
linear_equiv.to_Module_iso' {M N : Module.{v} R} (i : M ≃ₗ[R] N) : M ≅ N | { hom := i,
inv := i.symm,
hom_inv_id' := linear_map.ext $ λ x, by simp,
inv_hom_id' := linear_map.ext $ λ x, by simp } | def | linear_equiv.to_Module_iso' | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"linear_map.ext"
] | Build an isomorphism in the category `Module R` from a `linear_equiv` between `module`s.
This version is better than `linear_equiv_to_Module_iso` when applicable, because Lean can't see
`Module.of R M` is defeq to `M` when `M : Module R`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
linear_equiv.to_Module_iso'_left {X₁ : Module.{v} R} {g₂ : add_comm_group X₂} {m₂ : module R X₂}
(e : X₁ ≃ₗ[R] X₂) : X₁ ≅ Module.of R X₂ | { hom := (e : X₁ →ₗ[R] X₂),
inv := (e.symm : X₂ →ₗ[R] X₁),
hom_inv_id' := linear_map.ext $ λ x, by simp,
inv_hom_id' := linear_map.ext $ λ x, by simp } | def | linear_equiv.to_Module_iso'_left | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"Module.of",
"add_comm_group",
"linear_map.ext",
"module"
] | Build an isomorphism in the category `Module R` from a `linear_equiv` between `module`s.
This version is better than `linear_equiv_to_Module_iso` when applicable, because Lean can't see
`Module.of R M` is defeq to `M` when `M : Module R`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
linear_equiv.to_Module_iso'_right {g₁ : add_comm_group X₁} {m₁ : module R X₁}
{X₂ : Module.{v} R} (e : X₁ ≃ₗ[R] X₂) : Module.of R X₁ ≅ X₂ | { hom := (e : X₁ →ₗ[R] X₂),
inv := (e.symm : X₂ →ₗ[R] X₁),
hom_inv_id' := linear_map.ext $ λ x, by simp,
inv_hom_id' := linear_map.ext $ λ x, by simp } | def | linear_equiv.to_Module_iso'_right | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"Module.of",
"add_comm_group",
"linear_map.ext",
"module"
] | Build an isomorphism in the category `Module R` from a `linear_equiv` between `module`s.
This version is better than `linear_equiv_to_Module_iso` when applicable, because Lean can't see
`Module.of R M` is defeq to `M` when `M : Module R`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
to_linear_equiv {X Y : Module R} (i : X ≅ Y) : X ≃ₗ[R] Y | { to_fun := i.hom,
inv_fun := i.inv,
left_inv := by tidy,
right_inv := by tidy,
map_add' := by tidy,
map_smul' := by tidy, }. | def | category_theory.iso.to_linear_equiv | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"Module",
"inv_fun"
] | Build a `linear_equiv` from an isomorphism in the category `Module R`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
linear_equiv_iso_Module_iso {X Y : Type u} [add_comm_group X] [add_comm_group Y] [module R X]
[module R Y] :
(X ≃ₗ[R] Y) ≅ (Module.of R X ≅ Module.of R Y) | { hom := λ e, e.to_Module_iso,
inv := λ i, i.to_linear_equiv, } | def | linear_equiv_iso_Module_iso | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"Module.of",
"add_comm_group",
"module"
] | linear equivalences between `module`s are the same as (isomorphic to) isomorphisms
in `Module` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
forget₂_AddCommGroup_additive : (forget₂ (Module.{v} R) AddCommGroup).additive | {} | instance | Module.forget₂_AddCommGroup_additive | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"additive"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
iso.hom_congr_eq_arrow_congr (i : X ≅ X') (j : Y ≅ Y') (f : X ⟶ Y) :
iso.hom_congr i j f = linear_equiv.arrow_congr i.to_linear_equiv j.to_linear_equiv f | rfl | lemma | Module.iso.hom_congr_eq_arrow_congr | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"linear_equiv.arrow_congr"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
iso.conj_eq_conj (i : X ≅ X') (f : End X) :
iso.conj i f = linear_equiv.conj i.to_linear_equiv f | rfl | lemma | Module.iso.conj_eq_conj | algebra.category.Module | src/algebra/category/Module/basic.lean | [
"algebra.category.Group.preadditive",
"category_theory.linear.basic",
"category_theory.elementwise",
"linear_algebra.basic",
"category_theory.conj",
"category_theory.preadditive.additive_functor"
] | [
"linear_equiv.conj"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
binary_product_limit_cone (M N : Module.{v} R) : limits.limit_cone (pair M N) | { cone :=
{ X := Module.of R (M × N),
π :=
{ app := λ j, discrete.cases_on j
(λ j, walking_pair.cases_on j (linear_map.fst R M N) (linear_map.snd R M N)),
naturality' := by rintros ⟨⟨⟩⟩ ⟨⟨⟩⟩ ⟨⟨⟨⟩⟩⟩; refl, }},
is_limit :=
{ lift := λ s, linear_map.prod (s.π.app ⟨walking_pair.left⟩) (s.π.app ... | def | Module.binary_product_limit_cone | algebra.category.Module | src/algebra/category/Module/biproducts.lean | [
"algebra.group.pi",
"category_theory.limits.shapes.biproducts",
"algebra.category.Module.abelian",
"algebra.homology.short_exact.abelian"
] | [
"Module.coe_comp",
"Module.of",
"lift",
"linear_map.fst",
"linear_map.fst_apply",
"linear_map.prod",
"linear_map.snd",
"linear_map.snd_apply",
"pi.prod"
] | Construct limit data for a binary product in `Module R`, using `Module.of R (M × N)`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
binary_product_limit_cone_cone_π_app_left (M N : Module.{v} R) :
(binary_product_limit_cone M N).cone.π.app ⟨walking_pair.left⟩ = linear_map.fst R M N | rfl | lemma | Module.binary_product_limit_cone_cone_π_app_left | algebra.category.Module | src/algebra/category/Module/biproducts.lean | [
"algebra.group.pi",
"category_theory.limits.shapes.biproducts",
"algebra.category.Module.abelian",
"algebra.homology.short_exact.abelian"
] | [
"linear_map.fst"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
binary_product_limit_cone_cone_π_app_right (M N : Module.{v} R) :
(binary_product_limit_cone M N).cone.π.app ⟨walking_pair.right⟩ = linear_map.snd R M N | rfl | lemma | Module.binary_product_limit_cone_cone_π_app_right | algebra.category.Module | src/algebra/category/Module/biproducts.lean | [
"algebra.group.pi",
"category_theory.limits.shapes.biproducts",
"algebra.category.Module.abelian",
"algebra.homology.short_exact.abelian"
] | [
"linear_map.snd"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
biprod_iso_prod (M N : Module.{v} R) : (M ⊞ N : Module.{v} R) ≅ Module.of R (M × N) | is_limit.cone_point_unique_up_to_iso
(binary_biproduct.is_limit M N)
(binary_product_limit_cone M N).is_limit | def | Module.biprod_iso_prod | algebra.category.Module | src/algebra/category/Module/biproducts.lean | [
"algebra.group.pi",
"category_theory.limits.shapes.biproducts",
"algebra.category.Module.abelian",
"algebra.homology.short_exact.abelian"
] | [
"Module.of"
] | We verify that the biproduct in `Module R` is isomorphic to
the cartesian product of the underlying types: | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
biprod_iso_prod_inv_comp_fst (M N : Module.{v} R) :
(biprod_iso_prod M N).inv ≫ biprod.fst = linear_map.fst R M N | is_limit.cone_point_unique_up_to_iso_inv_comp _ _ (discrete.mk walking_pair.left) | lemma | Module.biprod_iso_prod_inv_comp_fst | algebra.category.Module | src/algebra/category/Module/biproducts.lean | [
"algebra.group.pi",
"category_theory.limits.shapes.biproducts",
"algebra.category.Module.abelian",
"algebra.homology.short_exact.abelian"
] | [
"linear_map.fst"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.