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 |
|---|---|---|---|---|---|---|---|---|---|---|
neg_smul : -r • x = - (r • x) | eq_neg_of_add_eq_zero_left $ by rw [← add_smul, add_left_neg, zero_smul] | theorem | neg_smul | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_smul",
"zero_smul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
neg_smul_neg : -r • -x = r • x | by rw [neg_smul, smul_neg, neg_neg] | lemma | neg_smul_neg | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"neg_smul",
"smul_neg"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
units.neg_smul (u : Rˣ) (x : M) : -u • x = - (u • x) | by rw [units.smul_def, units.coe_neg, neg_smul, units.smul_def] | theorem | units.neg_smul | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"neg_smul",
"units.coe_neg",
"units.smul_def"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
neg_one_smul (x : M) : (-1 : R) • x = -x | by simp | theorem | neg_one_smul | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sub_smul (r s : R) (y : M) : (r - s) • y = r • y - s • y | by simp [add_smul, sub_eq_add_neg] | theorem | sub_smul | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_smul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
module.subsingleton (R M : Type*) [semiring R] [subsingleton R]
[add_comm_monoid M] [module R M] :
subsingleton M | mul_action_with_zero.subsingleton R M | theorem | module.subsingleton | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_monoid",
"module",
"mul_action_with_zero.subsingleton",
"semiring"
] | A module over a `subsingleton` semiring is a `subsingleton`. We cannot register this
as an instance because Lean has no way to guess `R`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
module.nontrivial (R M : Type*) [semiring R] [nontrivial M] [add_comm_monoid M]
[module R M] :
nontrivial R | mul_action_with_zero.nontrivial R M | theorem | module.nontrivial | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_monoid",
"module",
"mul_action_with_zero.nontrivial",
"nontrivial",
"semiring"
] | A semiring is `nontrivial` provided that there exists a nontrivial module over this semiring. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
semiring.to_module [semiring R] : module R R | { smul_add := mul_add,
add_smul := add_mul,
zero_smul := zero_mul,
smul_zero := mul_zero } | instance | semiring.to_module | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_smul",
"module",
"mul_zero",
"semiring",
"smul_add",
"smul_zero",
"zero_mul",
"zero_smul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
semiring.to_opposite_module [semiring R] : module Rᵐᵒᵖ R | { smul_add := λ r x y, add_mul _ _ _,
add_smul := λ r x y, mul_add _ _ _,
..monoid_with_zero.to_opposite_mul_action_with_zero R} | instance | semiring.to_opposite_module | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_smul",
"module",
"monoid_with_zero.to_opposite_mul_action_with_zero",
"semiring",
"smul_add"
] | Like `semiring.to_module`, but multiplies on the right. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
ring_hom.to_module [semiring R] [semiring S] (f : R →+* S) : module R S | module.comp_hom S f | def | ring_hom.to_module | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"module",
"module.comp_hom",
"semiring"
] | A ring homomorphism `f : R →+* M` defines a module structure by `r • x = f r * x`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
ring_hom.apply_distrib_mul_action [semiring R] : distrib_mul_action (R →+* R) R | { smul := ($),
smul_zero := ring_hom.map_zero,
smul_add := ring_hom.map_add,
one_smul := λ _, rfl,
mul_smul := λ _ _ _, rfl } | instance | ring_hom.apply_distrib_mul_action | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"distrib_mul_action",
"one_smul",
"ring_hom.map_add",
"ring_hom.map_zero",
"semiring",
"smul_add",
"smul_zero"
] | The tautological action by `R →+* R` on `R`.
This generalizes `function.End.apply_mul_action`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
ring_hom.smul_def [semiring R] (f : R →+* R) (a : R) :
f • a = f a | rfl | lemma | ring_hom.smul_def | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ring_hom.apply_has_faithful_smul [semiring R] : has_faithful_smul (R →+* R) R | ⟨ring_hom.ext⟩ | instance | ring_hom.apply_has_faithful_smul | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"has_faithful_smul",
"semiring"
] | `ring_hom.apply_distrib_mul_action` is faithful. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
nsmul_eq_smul_cast (n : ℕ) (b : M) :
n • b = (n : R) • b | begin
induction n with n ih,
{ rw [nat.cast_zero, zero_smul, zero_smul] },
{ rw [nat.succ_eq_add_one, nat.cast_succ, add_smul, add_smul, one_smul, ih, one_smul], }
end | lemma | nsmul_eq_smul_cast | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_smul",
"ih",
"nat.cast_succ",
"nat.cast_zero",
"one_smul",
"zero_smul"
] | `nsmul` is equal to any other module structure via a cast. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
nat_smul_eq_nsmul (h : module ℕ M) (n : ℕ) (x : M) :
@has_smul.smul ℕ M h.to_has_smul n x = n • x | by rw [nsmul_eq_smul_cast ℕ n x, nat.cast_id] | lemma | nat_smul_eq_nsmul | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"module",
"nat.cast_id",
"nsmul_eq_smul_cast"
] | Convert back any exotic `ℕ`-smul to the canonical instance. This should not be needed since in
mathlib all `add_comm_monoid`s should normally have exactly one `ℕ`-module structure by design. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
add_comm_monoid.nat_module.unique : unique (module ℕ M) | { default := by apply_instance,
uniq := λ P, module.ext' P _ $ λ n, nat_smul_eq_nsmul P n } | def | add_comm_monoid.nat_module.unique | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"module",
"module.ext'",
"nat_smul_eq_nsmul",
"unique"
] | All `ℕ`-module structures are equal. Not an instance since in mathlib all `add_comm_monoid`
should normally have exactly one `ℕ`-module structure by design. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
add_comm_monoid.nat_is_scalar_tower :
is_scalar_tower ℕ R M | { smul_assoc := λ n x y, nat.rec_on n
(by simp only [zero_smul])
(λ n ih, by simp only [nat.succ_eq_add_one, add_smul, one_smul, ih]) } | instance | add_comm_monoid.nat_is_scalar_tower | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_smul",
"ih",
"is_scalar_tower",
"one_smul",
"smul_assoc",
"zero_smul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
zsmul_eq_smul_cast (n : ℤ) (b : M) : n • b = (n : R) • b | have (smul_add_hom ℤ M).flip b = ((smul_add_hom R M).flip b).comp (int.cast_add_hom R),
by { ext, simp },
add_monoid_hom.congr_fun this n | lemma | zsmul_eq_smul_cast | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"int.cast_add_hom",
"smul_add_hom"
] | `zsmul` is equal to any other module structure via a cast. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
int_smul_eq_zsmul (h : module ℤ M) (n : ℤ) (x : M) :
@has_smul.smul ℤ M h.to_has_smul n x = n • x | by rw [zsmul_eq_smul_cast ℤ n x, int.cast_id] | lemma | int_smul_eq_zsmul | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"int.cast_id",
"module",
"zsmul_eq_smul_cast"
] | Convert back any exotic `ℤ`-smul to the canonical instance. This should not be needed since in
mathlib all `add_comm_group`s should normally have exactly one `ℤ`-module structure by design. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
add_comm_group.int_module.unique : unique (module ℤ M) | { default := by apply_instance,
uniq := λ P, module.ext' P _ $ λ n, int_smul_eq_zsmul P n } | def | add_comm_group.int_module.unique | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"int_smul_eq_zsmul",
"module",
"module.ext'",
"unique"
] | All `ℤ`-module structures are equal. Not an instance since in mathlib all `add_comm_group`
should normally have exactly one `ℤ`-module structure by design. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
map_int_cast_smul [add_comm_group M] [add_comm_group M₂] {F : Type*}
[add_monoid_hom_class F M M₂] (f : F) (R S : Type*) [ring R] [ring S] [module R M] [module S M₂]
(x : ℤ) (a : M) : f ((x : R) • a) = (x : S) • f a | by simp only [←zsmul_eq_smul_cast, map_zsmul] | lemma | map_int_cast_smul | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_group",
"add_monoid_hom_class",
"map_zsmul",
"module",
"ring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_nat_cast_smul [add_comm_monoid M] [add_comm_monoid M₂] {F : Type*}
[add_monoid_hom_class F M M₂] (f : F)
(R S : Type*) [semiring R] [semiring S] [module R M] [module S M₂] (x : ℕ) (a : M) :
f ((x : R) • a) = (x : S) • f a | by simp only [←nsmul_eq_smul_cast, map_nsmul] | lemma | map_nat_cast_smul | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_monoid",
"add_monoid_hom_class",
"map_nsmul",
"module",
"semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_inv_nat_cast_smul [add_comm_monoid M] [add_comm_monoid M₂] {F : Type*}
[add_monoid_hom_class F M M₂] (f : F)
(R S : Type*) [division_semiring R] [division_semiring S] [module R M] [module S M₂]
(n : ℕ) (x : M) :
f ((n⁻¹ : R) • x) = (n⁻¹ : S) • f x | begin
by_cases hR : (n : R) = 0; by_cases hS : (n : S) = 0,
{ simp [hR, hS] },
{ suffices : ∀ y, f y = 0, by simp [this], clear x, intro x,
rw [← inv_smul_smul₀ hS (f x), ← map_nat_cast_smul f R S], simp [hR] },
{ suffices : ∀ y, f y = 0, by simp [this], clear x, intro x,
rw [← smul_inv_smul₀ hR x, map_... | lemma | map_inv_nat_cast_smul | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_monoid",
"add_monoid_hom_class",
"division_semiring",
"inv_smul_smul₀",
"map_nat_cast_smul",
"module",
"smul_inv_smul₀",
"zero_smul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_inv_int_cast_smul [add_comm_group M] [add_comm_group M₂] {F : Type*}
[add_monoid_hom_class F M M₂] (f : F)
(R S : Type*) [division_ring R] [division_ring S] [module R M] [module S M₂]
(z : ℤ) (x : M) :
f ((z⁻¹ : R) • x) = (z⁻¹ : S) • f x | begin
obtain ⟨n, rfl | rfl⟩ := z.eq_coe_or_neg,
{ rw [int.cast_coe_nat, int.cast_coe_nat, map_inv_nat_cast_smul _ R S] },
{ simp_rw [int.cast_neg, int.cast_coe_nat, inv_neg, neg_smul, map_neg,
map_inv_nat_cast_smul _ R S] },
end | lemma | map_inv_int_cast_smul | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_group",
"add_monoid_hom_class",
"division_ring",
"int.cast_coe_nat",
"int.cast_neg",
"inv_neg",
"map_inv_nat_cast_smul",
"module",
"neg_smul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_rat_cast_smul [add_comm_group M] [add_comm_group M₂] {F : Type*}
[add_monoid_hom_class F M M₂] (f : F)
(R S : Type*) [division_ring R] [division_ring S] [module R M] [module S M₂]
(c : ℚ) (x : M) :
f ((c : R) • x) = (c : S) • f x | by rw [rat.cast_def, rat.cast_def, div_eq_mul_inv, div_eq_mul_inv, mul_smul, mul_smul,
map_int_cast_smul f R S, map_inv_nat_cast_smul f R S] | lemma | map_rat_cast_smul | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_group",
"add_monoid_hom_class",
"div_eq_mul_inv",
"division_ring",
"map_int_cast_smul",
"map_inv_nat_cast_smul",
"module",
"rat.cast_def"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_rat_smul [add_comm_group M] [add_comm_group M₂] [module ℚ M] [module ℚ M₂] {F : Type*}
[add_monoid_hom_class F M M₂] (f : F) (c : ℚ) (x : M) :
f (c • x) = c • f x | rat.cast_id c ▸ map_rat_cast_smul f ℚ ℚ c x | lemma | map_rat_smul | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_group",
"add_monoid_hom_class",
"map_rat_cast_smul",
"module",
"rat.cast_id"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
subsingleton_rat_module (E : Type*) [add_comm_group E] : subsingleton (module ℚ E) | ⟨λ P Q, module.ext' P Q $ λ r x,
@map_rat_smul _ _ _ _ P Q _ _ (add_monoid_hom.id E) r x⟩ | instance | subsingleton_rat_module | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_group",
"map_rat_smul",
"module",
"module.ext'"
] | There can be at most one `module ℚ E` structure on an additive commutative group. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
inv_nat_cast_smul_eq {E : Type*} (R S : Type*) [add_comm_monoid E] [division_semiring R]
[division_semiring S] [module R E] [module S E] (n : ℕ) (x : E) :
(n⁻¹ : R) • x = (n⁻¹ : S) • x | map_inv_nat_cast_smul (add_monoid_hom.id E) R S n x | lemma | inv_nat_cast_smul_eq | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_monoid",
"division_semiring",
"map_inv_nat_cast_smul",
"module"
] | If `E` is a vector space over two division semirings `R` and `S`, then scalar multiplications
agree on inverses of natural numbers in `R` and `S`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
inv_int_cast_smul_eq {E : Type*} (R S : Type*) [add_comm_group E] [division_ring R]
[division_ring S] [module R E] [module S E] (n : ℤ) (x : E) :
(n⁻¹ : R) • x = (n⁻¹ : S) • x | map_inv_int_cast_smul (add_monoid_hom.id E) R S n x | lemma | inv_int_cast_smul_eq | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_group",
"division_ring",
"map_inv_int_cast_smul",
"module"
] | If `E` is a vector space over two division rings `R` and `S`, then scalar multiplications
agree on inverses of integer numbers in `R` and `S`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
inv_nat_cast_smul_comm {α E : Type*} (R : Type*) [add_comm_monoid E] [division_semiring R]
[monoid α] [module R E] [distrib_mul_action α E] (n : ℕ) (s : α) (x : E) :
(n⁻¹ : R) • s • x = s • (n⁻¹ : R) • x | (map_inv_nat_cast_smul (distrib_mul_action.to_add_monoid_hom E s) R R n x).symm | lemma | inv_nat_cast_smul_comm | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_monoid",
"distrib_mul_action",
"distrib_mul_action.to_add_monoid_hom",
"division_semiring",
"map_inv_nat_cast_smul",
"module",
"monoid"
] | If `E` is a vector space over a division ring `R` and has a monoid action by `α`, then that
action commutes by scalar multiplication of inverses of natural numbers in `R`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
inv_int_cast_smul_comm {α E : Type*} (R : Type*) [add_comm_group E] [division_ring R]
[monoid α] [module R E] [distrib_mul_action α E] (n : ℤ) (s : α) (x : E) :
(n⁻¹ : R) • s • x = s • (n⁻¹ : R) • x | (map_inv_int_cast_smul (distrib_mul_action.to_add_monoid_hom E s) R R n x).symm | lemma | inv_int_cast_smul_comm | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_group",
"distrib_mul_action",
"distrib_mul_action.to_add_monoid_hom",
"division_ring",
"map_inv_int_cast_smul",
"module",
"monoid"
] | If `E` is a vector space over a division ring `R` and has a monoid action by `α`, then that
action commutes by scalar multiplication of inverses of integers in `R` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
rat_cast_smul_eq {E : Type*} (R S : Type*) [add_comm_group E] [division_ring R]
[division_ring S] [module R E] [module S E] (r : ℚ) (x : E) :
(r : R) • x = (r : S) • x | map_rat_cast_smul (add_monoid_hom.id E) R S r x | lemma | rat_cast_smul_eq | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_group",
"division_ring",
"map_rat_cast_smul",
"module"
] | If `E` is a vector space over two division rings `R` and `S`, then scalar multiplications
agree on rational numbers in `R` and `S`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
add_comm_group.int_is_scalar_tower {R : Type u} {M : Type v} [ring R] [add_comm_group M]
[module R M]: is_scalar_tower ℤ R M | { smul_assoc := λ n x y, ((smul_add_hom R M).flip y).map_zsmul x n } | instance | add_comm_group.int_is_scalar_tower | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_group",
"is_scalar_tower",
"map_zsmul",
"module",
"ring",
"smul_add_hom",
"smul_assoc"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_scalar_tower.rat {R : Type u} {M : Type v} [ring R] [add_comm_group M]
[module R M] [module ℚ R] [module ℚ M] : is_scalar_tower ℚ R M | { smul_assoc := λ r x y, map_rat_smul ((smul_add_hom R M).flip y) r x } | instance | is_scalar_tower.rat | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_group",
"is_scalar_tower",
"map_rat_smul",
"module",
"ring",
"smul_add_hom",
"smul_assoc"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
smul_comm_class.rat {R : Type u} {M : Type v} [semiring R] [add_comm_group M]
[module R M] [module ℚ M] : smul_comm_class ℚ R M | { smul_comm := λ r x y, (map_rat_smul (smul_add_hom R M x) r y).symm } | instance | smul_comm_class.rat | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_group",
"map_rat_smul",
"module",
"semiring",
"smul_add_hom",
"smul_comm_class"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
smul_comm_class.rat' {R : Type u} {M : Type v} [semiring R] [add_comm_group M]
[module R M] [module ℚ M] : smul_comm_class R ℚ M | smul_comm_class.symm _ _ _ | instance | smul_comm_class.rat' | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_group",
"module",
"semiring",
"smul_comm_class",
"smul_comm_class.symm"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
no_zero_smul_divisors (R M : Type*) [has_zero R] [has_zero M] [has_smul R M] : Prop | (eq_zero_or_eq_zero_of_smul_eq_zero : ∀ {c : R} {x : M}, c • x = 0 → c = 0 ∨ x = 0) | class | no_zero_smul_divisors | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"has_smul"
] | `no_zero_smul_divisors R M` states that a scalar multiple is `0` only if either argument is `0`.
This a version of saying that `M` is torsion free, without assuming `R` is zero-divisor free.
The main application of `no_zero_smul_divisors R M`, when `M` is a module,
is the result `smul_eq_zero`: a scalar multiple is `0... | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
function.injective.no_zero_smul_divisors {R M N : Type*} [has_zero R] [has_zero M]
[has_zero N] [has_smul R M] [has_smul R N] [no_zero_smul_divisors R N] (f : M → N)
(hf : function.injective f) (h0 : f 0 = 0) (hs : ∀ (c : R) (x : M), f (c • x) = c • f x) :
no_zero_smul_divisors R M | ⟨λ c m h,
or.imp_right (@hf _ _) $ h0.symm ▸ eq_zero_or_eq_zero_of_smul_eq_zero (by rw [←hs, h, h0])⟩ | lemma | function.injective.no_zero_smul_divisors | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"has_smul",
"no_zero_smul_divisors"
] | Pullback a `no_zero_smul_divisors` instance along an injective function. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
no_zero_divisors.to_no_zero_smul_divisors [has_zero R] [has_mul R] [no_zero_divisors R] :
no_zero_smul_divisors R R | ⟨λ c x, eq_zero_or_eq_zero_of_mul_eq_zero⟩ | instance | no_zero_divisors.to_no_zero_smul_divisors | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"no_zero_divisors",
"no_zero_smul_divisors"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
smul_ne_zero [has_zero R] [has_zero M] [has_smul R M] [no_zero_smul_divisors R M] {c : R}
{x : M} (hc : c ≠ 0) (hx : x ≠ 0) : c • x ≠ 0 | λ h, (eq_zero_or_eq_zero_of_smul_eq_zero h).elim hc hx | lemma | smul_ne_zero | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"has_smul",
"no_zero_smul_divisors"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
smul_eq_zero : c • x = 0 ↔ c = 0 ∨ x = 0 | ⟨eq_zero_or_eq_zero_of_smul_eq_zero,
λ h, h.elim (λ h, h.symm ▸ zero_smul R x) (λ h, h.symm ▸ smul_zero c)⟩ | lemma | smul_eq_zero | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"smul_zero",
"zero_smul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
smul_ne_zero_iff : c • x ≠ 0 ↔ c ≠ 0 ∧ x ≠ 0 | by rw [ne.def, smul_eq_zero, not_or_distrib] | lemma | smul_ne_zero_iff | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"not_or_distrib",
"smul_eq_zero"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
nat.no_zero_smul_divisors : no_zero_smul_divisors ℕ M | ⟨by { intros c x, rw [nsmul_eq_smul_cast R, smul_eq_zero], simp }⟩ | lemma | nat.no_zero_smul_divisors | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"no_zero_smul_divisors",
"nsmul_eq_smul_cast",
"smul_eq_zero"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
two_nsmul_eq_zero {v : M} : 2 • v = 0 ↔ v = 0 | by { haveI := nat.no_zero_smul_divisors R M, simp [smul_eq_zero] } | lemma | two_nsmul_eq_zero | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"nat.no_zero_smul_divisors",
"smul_eq_zero"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
char_zero.of_module (M) [add_comm_monoid_with_one M] [char_zero M] [module R M] :
char_zero R | begin
refine ⟨λ m n h, @nat.cast_injective M _ _ _ _ _⟩,
rw [← nsmul_one, ← nsmul_one, nsmul_eq_smul_cast R m (1 : M), nsmul_eq_smul_cast R n (1 : M), h]
end | lemma | char_zero.of_module | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_monoid_with_one",
"char_zero",
"module",
"nat.cast_injective",
"nsmul_eq_smul_cast",
"nsmul_one"
] | If `M` is an `R`-module with one and `M` has characteristic zero, then `R` has characteristic
zero as well. Usually `M` is an `R`-algebra. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
smul_right_injective [no_zero_smul_divisors R M] {c : R} (hc : c ≠ 0) :
function.injective ((•) c : M → M) | (injective_iff_map_eq_zero (smul_add_hom R M c)).2 $ λ a ha, (smul_eq_zero.mp ha).resolve_left hc | lemma | smul_right_injective | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"no_zero_smul_divisors",
"smul_add_hom"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
smul_right_inj [no_zero_smul_divisors R M] {c : R} (hc : c ≠ 0) {x y : M} :
c • x = c • y ↔ x = y | (smul_right_injective M hc).eq_iff | lemma | smul_right_inj | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"no_zero_smul_divisors",
"smul_right_injective"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
self_eq_neg {v : M} : v = - v ↔ v = 0 | by rw [← two_nsmul_eq_zero R M, two_smul, add_eq_zero_iff_eq_neg] | lemma | self_eq_neg | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"two_nsmul_eq_zero",
"two_smul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
neg_eq_self {v : M} : - v = v ↔ v = 0 | by rw [eq_comm, self_eq_neg R M] | lemma | neg_eq_self | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"self_eq_neg"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
self_ne_neg {v : M} : v ≠ -v ↔ v ≠ 0 | (self_eq_neg R M).not | lemma | self_ne_neg | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"self_eq_neg"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
neg_ne_self {v : M} : -v ≠ v ↔ v ≠ 0 | (neg_eq_self R M).not | lemma | neg_ne_self | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"neg_eq_self"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
smul_left_injective {x : M} (hx : x ≠ 0) :
function.injective (λ (c : R), c • x) | λ c d h, sub_eq_zero.mp ((smul_eq_zero.mp
(calc (c - d) • x = c • x - d • x : sub_smul c d x
... = 0 : sub_eq_zero.mpr h)).resolve_right hx) | lemma | smul_left_injective | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"sub_smul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
group_with_zero.to_no_zero_smul_divisors : no_zero_smul_divisors R M | ⟨λ c x h, or_iff_not_imp_left.2 $ λ hc, (smul_eq_zero_iff_eq' hc).1 h⟩ | instance | group_with_zero.to_no_zero_smul_divisors | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"no_zero_smul_divisors",
"smul_eq_zero_iff_eq'"
] | This instance applies to `division_semiring`s, in particular `nnreal` and `nnrat`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
rat_module.no_zero_smul_divisors [add_comm_group M] [module ℚ M] :
no_zero_smul_divisors ℤ M | ⟨λ k x h, by simpa [zsmul_eq_smul_cast ℚ k x] using h⟩ | instance | rat_module.no_zero_smul_divisors | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"add_comm_group",
"module",
"no_zero_smul_divisors",
"zsmul_eq_smul_cast"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
nat.smul_one_eq_coe {R : Type*} [semiring R] (m : ℕ) :
m • (1 : R) = ↑m | by rw [nsmul_eq_mul, mul_one] | lemma | nat.smul_one_eq_coe | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"mul_one",
"nsmul_eq_mul",
"semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
int.smul_one_eq_coe {R : Type*} [ring R] (m : ℤ) :
m • (1 : R) = ↑m | by rw [zsmul_eq_mul, mul_one] | lemma | int.smul_one_eq_coe | algebra.module | src/algebra/module/basic.lean | [
"algebra.smul_with_zero",
"group_theory.group_action.group",
"tactic.abel"
] | [
"mul_one",
"ring",
"zsmul_eq_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
list.sum_smul {l : list R} {x : M} : l.sum • x = (l.map (λ r, r • x)).sum | ((smul_add_hom R M).flip x).map_list_sum l | lemma | list.sum_smul | algebra.module | src/algebra/module/big_operators.lean | [
"algebra.module.basic",
"group_theory.group_action.big_operators"
] | [
"smul_add_hom"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
multiset.sum_smul {l : multiset R} {x : M} : l.sum • x = (l.map (λ r, r • x)).sum | ((smul_add_hom R M).flip x).map_multiset_sum l | lemma | multiset.sum_smul | algebra.module | src/algebra/module/big_operators.lean | [
"algebra.module.basic",
"group_theory.group_action.big_operators"
] | [
"multiset",
"smul_add_hom"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
multiset.sum_smul_sum {s : multiset R} {t : multiset M} :
s.sum • t.sum = ((s ×ˢ t).map $ λ p : R × M, p.fst • p.snd).sum | begin
induction s using multiset.induction with a s ih,
{ simp },
{ simp [add_smul, ih, ←multiset.smul_sum] }
end | lemma | multiset.sum_smul_sum | algebra.module | src/algebra/module/big_operators.lean | [
"algebra.module.basic",
"group_theory.group_action.big_operators"
] | [
"add_smul",
"ih",
"multiset",
"multiset.induction"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
finset.sum_smul {f : ι → R} {s : finset ι} {x : M} :
(∑ i in s, f i) • x = (∑ i in s, (f i) • x) | ((smul_add_hom R M).flip x).map_sum f s | lemma | finset.sum_smul | algebra.module | src/algebra/module/big_operators.lean | [
"algebra.module.basic",
"group_theory.group_action.big_operators"
] | [
"finset",
"smul_add_hom"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
finset.sum_smul_sum {f : α → R} {g : β → M} {s : finset α} {t : finset β} :
(∑ i in s, f i) • (∑ i in t, g i) = ∑ p in s ×ˢ t, f p.fst • g p.snd | by { rw [finset.sum_product, finset.sum_smul, finset.sum_congr rfl], intros, rw finset.smul_sum } | lemma | finset.sum_smul_sum | algebra.module | src/algebra/module/big_operators.lean | [
"algebra.module.basic",
"group_theory.group_action.big_operators"
] | [
"finset",
"finset.smul_sum",
"finset.sum_smul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
finset.cast_card [comm_semiring R] (s : finset α) : (s.card : R) = ∑ a in s, 1 | by rw [finset.sum_const, nat.smul_one_eq_coe] | lemma | finset.cast_card | algebra.module | src/algebra/module/big_operators.lean | [
"algebra.module.basic",
"group_theory.group_action.big_operators"
] | [
"comm_semiring",
"finset",
"nat.smul_one_eq_coe"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mk (p : add_submonoid M)
(hA : ∀ (a : A) {m : M}, m ∈ p → a • m ∈ p)
(hB : ∀ (b : B) {m : M}, m ∈ p → b • m ∈ p) : submodule (A ⊗[R] B) M | { carrier := p,
smul_mem' := λ ab m, tensor_product.induction_on ab
(λ hm, by simpa only [zero_smul] using p.zero_mem)
(λ a b hm, by simpa only [tensor_product.algebra.smul_def] using hA a (hB b hm))
(λ z w hz hw hm, by simpa only [add_smul] using p.add_mem (hz hm) (hw hm)),
.. p } | def | subbimodule.mk | algebra.module | src/algebra/module/bimodule.lean | [
"ring_theory.tensor_product"
] | [
"add_smul",
"add_submonoid",
"submodule",
"tensor_product.algebra.smul_def",
"tensor_product.induction_on",
"zero_smul"
] | A constructor for a subbimodule which demands closure under the two sets of scalars
individually, rather than jointly via their tensor product.
Note that `R` plays no role but it is convenient to make this generalisation to support the cases
`R = ℕ` and `R = ℤ` which both show up naturally. See also `base_change`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
smul_mem (p : submodule (A ⊗[R] B) M) (a : A) {m : M} (hm : m ∈ p) : a • m ∈ p | begin
suffices : a • m = a ⊗ₜ[R] (1 : B) • m, { exact this.symm ▸ p.smul_mem _ hm, },
simp [tensor_product.algebra.smul_def],
end | lemma | subbimodule.smul_mem | algebra.module | src/algebra/module/bimodule.lean | [
"ring_theory.tensor_product"
] | [
"submodule",
"tensor_product.algebra.smul_def"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
smul_mem' (p : submodule (A ⊗[R] B) M) (b : B) {m : M} (hm : m ∈ p) : b • m ∈ p | begin
suffices : b • m = (1 : A) ⊗ₜ[R] b • m, { exact this.symm ▸ p.smul_mem _ hm, },
simp [tensor_product.algebra.smul_def],
end | lemma | subbimodule.smul_mem' | algebra.module | src/algebra/module/bimodule.lean | [
"ring_theory.tensor_product"
] | [
"submodule",
"tensor_product.algebra.smul_def"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
base_change (S : Type*) [comm_semiring S] [module S M] [algebra S A] [algebra S B]
[is_scalar_tower S A M] [is_scalar_tower S B M] (p : submodule (A ⊗[R] B) M) :
submodule (A ⊗[S] B) M | mk p.to_add_submonoid (smul_mem p) (smul_mem' p) | def | subbimodule.base_change | algebra.module | src/algebra/module/bimodule.lean | [
"ring_theory.tensor_product"
] | [
"algebra",
"comm_semiring",
"is_scalar_tower",
"module",
"submodule"
] | If `A` and `B` are also `algebra`s over yet another set of scalars `S` then we may "base change"
from `R` to `S`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
to_submodule (p : submodule (A ⊗[R] B) M) : submodule A M | { carrier := p,
smul_mem' := smul_mem p,
.. p } | def | subbimodule.to_submodule | algebra.module | src/algebra/module/bimodule.lean | [
"ring_theory.tensor_product"
] | [
"submodule"
] | Forgetting the `B` action, a `submodule` over `A ⊗[R] B` is just a `submodule` over `A`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
to_submodule' (p : submodule (A ⊗[R] B) M) : submodule B M | { carrier := p,
smul_mem' := smul_mem' p,
.. p } | def | subbimodule.to_submodule' | algebra.module | src/algebra/module/bimodule.lean | [
"ring_theory.tensor_product"
] | [
"submodule"
] | Forgetting the `A` action, a `submodule` over `A ⊗[R] B` is just a `submodule` over `B`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
to_subbimodule_int (p : submodule (R ⊗[ℕ] S) M) : submodule (R ⊗[ℤ] S) M | base_change ℤ p | def | subbimodule.to_subbimodule_int | algebra.module | src/algebra/module/bimodule.lean | [
"ring_theory.tensor_product"
] | [
"submodule"
] | A `submodule` over `R ⊗[ℕ] S` is naturally also a `submodule` over the canonically-isomorphic
ring `R ⊗[ℤ] S`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
to_subbimodule_nat (p : submodule (R ⊗[ℤ] S) M) : submodule (R ⊗[ℕ] S) M | base_change ℕ p | def | subbimodule.to_subbimodule_nat | algebra.module | src/algebra/module/bimodule.lean | [
"ring_theory.tensor_product"
] | [
"submodule"
] | A `submodule` over `R ⊗[ℤ] S` is naturally also a `submodule` over the canonically-isomorphic
ring `R ⊗[ℕ] S`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
is_internal_prime_power_torsion_of_is_torsion_by_ideal {I : ideal R} (hI : I ≠ ⊥)
(hM : module.is_torsion_by_set R M I) :
direct_sum.is_internal (λ p : (factors I).to_finset,
torsion_by_set R M (p ^ (factors I).count p : ideal R)) | begin
let P := factors I,
have prime_of_mem := λ p (hp : p ∈ P.to_finset), prime_of_factor p (multiset.mem_to_finset.mp hp),
apply @torsion_by_set_is_internal _ _ _ _ _ _ _ _ (λ p, p ^ P.count p) _,
{ convert hM,
rw [← finset.inf_eq_infi, is_dedekind_domain.inf_prime_pow_eq_prod,
← finset.prod_multise... | lemma | submodule.is_internal_prime_power_torsion_of_is_torsion_by_ideal | algebra.module | src/algebra/module/dedekind_domain.lean | [
"algebra.module.torsion",
"ring_theory.dedekind_domain.ideal"
] | [
"associated_iff_eq",
"direct_sum.is_internal",
"finset.inf_eq_infi",
"finset.prod_multiset_count",
"ideal",
"ideal.one_eq_top",
"ideal.zero_eq_bot",
"irreducible",
"irreducible_pow_sup",
"is_dedekind_domain.inf_prime_pow_eq_prod",
"module.is_torsion_by_set",
"multiset.count_eq_zero",
"multis... | Over a Dedekind domain, a `I`-torsion module is the internal direct sum of its `p i ^ e i`-
torsion submodules, where `I = ∏ i, p i ^ e i` is its unique decomposition in prime ideals. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
is_internal_prime_power_torsion [module.finite R M] (hM : module.is_torsion R M) :
direct_sum.is_internal (λ p : (factors (⊤ : submodule R M).annihilator).to_finset,
torsion_by_set R M (p ^ (factors (⊤ : submodule R M).annihilator).count p : ideal R)) | begin
have hM' := module.is_torsion_by_set_annihilator_top R M,
have hI := submodule.annihilator_top_inter_non_zero_divisors hM,
refine is_internal_prime_power_torsion_of_is_torsion_by_ideal _ hM',
rw ←set.nonempty_iff_ne_empty at hI, rw submodule.ne_bot_iff,
obtain ⟨x, H, hx⟩ := hI, exact ⟨x, H, non_zero_div... | theorem | submodule.is_internal_prime_power_torsion | algebra.module | src/algebra/module/dedekind_domain.lean | [
"algebra.module.torsion",
"ring_theory.dedekind_domain.ideal"
] | [
"direct_sum.is_internal",
"ideal",
"module.finite",
"module.is_torsion",
"module.is_torsion_by_set_annihilator_top",
"non_zero_divisors.ne_zero",
"submodule",
"submodule.annihilator_top_inter_non_zero_divisors",
"submodule.ne_bot_iff"
] | A finitely generated torsion module over a Dedekind domain is an internal direct sum of its
`p i ^ e i`-torsion submodules where `p i` are factors of `(⊤ : submodule R M).annihilator` and
`e i` are their multiplicities. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
exists_is_internal_prime_power_torsion [module.finite R M] (hM : module.is_torsion R M) :
∃ (P : finset $ ideal R) [decidable_eq P] [∀ p ∈ P, prime p] (e : P → ℕ),
by exactI direct_sum.is_internal (λ p : P, torsion_by_set R M (p ^ e p : ideal R)) | ⟨_, _, λ p hp, prime_of_factor p (multiset.mem_to_finset.mp hp), _,
is_internal_prime_power_torsion hM⟩ | theorem | submodule.exists_is_internal_prime_power_torsion | algebra.module | src/algebra/module/dedekind_domain.lean | [
"algebra.module.torsion",
"ring_theory.dedekind_domain.ideal"
] | [
"direct_sum.is_internal",
"finset",
"ideal",
"module.finite",
"module.is_torsion",
"prime"
] | A finitely generated torsion module over a Dedekind domain is an internal direct sum of its
`p i ^ e i`-torsion submodules for some prime ideals `p i` and numbers `e i`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
linear_equiv {R : Type*} {S : Type*} [semiring R] [semiring S] (σ : R →+* S)
{σ' : S →+* R} [ring_hom_inv_pair σ σ'] [ring_hom_inv_pair σ' σ]
(M : Type*) (M₂ : Type*)
[add_comm_monoid M] [add_comm_monoid M₂] [module R M] [module S M₂]
extends linear_map σ M M₂, M ≃+ M₂ | structure | linear_equiv | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [
"add_comm_monoid",
"linear_map",
"module",
"ring_hom_inv_pair",
"semiring"
] | A linear equivalence is an invertible linear map. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
semilinear_equiv_class (F : Type*) {R S : out_param Type*} [semiring R] [semiring S]
(σ : out_param $ R →+* S) {σ' : out_param $ S →+* R}
[ring_hom_inv_pair σ σ'] [ring_hom_inv_pair σ' σ] (M M₂ : out_param Type*)
[add_comm_monoid M] [add_comm_monoid M₂] [module R M] [module S M₂]
extends add_equiv_class F M M₂ | (map_smulₛₗ : ∀ (f : F) (r : R) (x : M), f (r • x) = (σ r) • f x) | class | semilinear_equiv_class | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [
"add_comm_monoid",
"add_equiv_class",
"module",
"ring_hom_inv_pair",
"semiring"
] | `semilinear_equiv_class F σ M M₂` asserts `F` is a type of bundled `σ`-semilinear equivs
`M → M₂`.
See also `linear_equiv_class F R M M₂` for the case where `σ` is the identity map on `R`.
A map `f` between an `R`-module and an `S`-module over a ring homomorphism `σ : R →+* S`
is semilinear if it satisfies the two pr... | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
linear_equiv_class (F : Type*) (R M M₂ : out_param Type*)
[semiring R] [add_comm_monoid M] [add_comm_monoid M₂] [module R M] [module R M₂] | semilinear_equiv_class F (ring_hom.id R) M M₂ | abbreviation | linear_equiv_class | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [
"add_comm_monoid",
"module",
"ring_hom.id",
"semilinear_equiv_class",
"semiring"
] | `linear_equiv_class F R M M₂` asserts `F` is a type of bundled `R`-linear equivs `M → M₂`.
This is an abbreviation for `semilinear_equiv_class F (ring_hom.id R) M M₂`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
coe_mk {to_fun inv_fun map_add map_smul left_inv right_inv } :
⇑(⟨to_fun, map_add, map_smul, inv_fun, left_inv, right_inv⟩ : M ≃ₛₗ[σ] M₂) = to_fun | rfl | lemma | linear_equiv.coe_mk | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [
"inv_fun"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_equiv : (M ≃ₛₗ[σ] M₂) → M ≃ M₂ | λ f, f.to_add_equiv.to_equiv | def | linear_equiv.to_equiv | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_equiv_injective : function.injective (to_equiv : (M ≃ₛₗ[σ] M₂) → M ≃ M₂) | λ ⟨_, _, _, _, _, _⟩ ⟨_, _, _, _, _, _⟩ h, linear_equiv.mk.inj_eq.mpr (equiv.mk.inj h) | lemma | linear_equiv.to_equiv_injective | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_equiv_inj {e₁ e₂ : M ≃ₛₗ[σ] M₂} : e₁.to_equiv = e₂.to_equiv ↔ e₁ = e₂ | to_equiv_injective.eq_iff | lemma | linear_equiv.to_equiv_inj | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_linear_map_injective :
injective (coe : (M ≃ₛₗ[σ] M₂) → (M →ₛₗ[σ] M₂)) | λ e₁ e₂ H, to_equiv_injective $ equiv.ext $ linear_map.congr_fun H | lemma | linear_equiv.to_linear_map_injective | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [
"equiv.ext",
"linear_map.congr_fun"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_linear_map_inj {e₁ e₂ : M ≃ₛₗ[σ] M₂} :
(e₁ : M →ₛₗ[σ] M₂) = e₂ ↔ e₁ = e₂ | to_linear_map_injective.eq_iff | lemma | linear_equiv.to_linear_map_inj | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_injective :
@injective (M ≃ₛₗ[σ] M₂) (M → M₂) coe_fn | fun_like.coe_injective | lemma | linear_equiv.coe_injective | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [
"fun_like.coe_injective"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_linear_map_eq_coe : e.to_linear_map = (e : M →ₛₗ[σ] M₂) | rfl | lemma | linear_equiv.to_linear_map_eq_coe | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_coe : ⇑(e : M →ₛₗ[σ] M₂) = e | rfl | theorem | linear_equiv.coe_coe | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [
"coe_coe"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_to_equiv : ⇑e.to_equiv = e | rfl | lemma | linear_equiv.coe_to_equiv | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_to_linear_map : ⇑e.to_linear_map = e | rfl | lemma | linear_equiv.coe_to_linear_map | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_fun_eq_coe : e.to_fun = e | rfl | lemma | linear_equiv.to_fun_eq_coe | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ext (h : ∀ x, e x = e' x) : e = e' | fun_like.ext _ _ h | lemma | linear_equiv.ext | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [
"fun_like.ext"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ext_iff : e = e' ↔ ∀ x, e x = e' x | fun_like.ext_iff | lemma | linear_equiv.ext_iff | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [
"fun_like.ext_iff"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
congr_arg {x x'} : x = x' → e x = e x' | fun_like.congr_arg e | lemma | linear_equiv.congr_arg | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [
"fun_like.congr_arg"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
congr_fun (h : e = e') (x : M) : e x = e' x | fun_like.congr_fun h x | lemma | linear_equiv.congr_fun | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [
"fun_like.congr_fun"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
refl [module R M] : M ≃ₗ[R] M | { .. linear_map.id, .. equiv.refl M } | def | linear_equiv.refl | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [
"equiv.refl",
"linear_map.id",
"module"
] | The identity map is a linear equivalence. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
refl_apply [module R M] (x : M) : refl R M x = x | rfl | lemma | linear_equiv.refl_apply | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [
"module"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
symm (e : M ≃ₛₗ[σ] M₂) : M₂ ≃ₛₗ[σ'] M | { to_fun := e.to_linear_map.inverse e.inv_fun e.left_inv e.right_inv,
inv_fun := e.to_equiv.symm.inv_fun,
map_smul' := λ r x, by rw map_smulₛₗ,
.. e.to_linear_map.inverse e.inv_fun e.left_inv e.right_inv,
.. e.to_equiv.symm } | def | linear_equiv.symm | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [
"inv_fun"
] | Linear equivalences are symmetric. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
simps.symm_apply {R : Type*} {S : Type*} [semiring R] [semiring S] {σ : R →+* S}
{σ' : S →+* R} [ring_hom_inv_pair σ σ'] [ring_hom_inv_pair σ' σ]
{M : Type*} {M₂ : Type*} [add_comm_monoid M] [add_comm_monoid M₂] [module R M] [module S M₂]
(e : M ≃ₛₗ[σ] M₂) : M₂ → M | e.symm
initialize_simps_projections linear_equiv (to_fun → apply, inv_fun → symm_apply) | def | linear_equiv.simps.symm_apply | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [
"add_comm_monoid",
"inv_fun",
"linear_equiv",
"module",
"ring_hom_inv_pair",
"semiring"
] | See Note [custom simps projection] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
inv_fun_eq_symm : e.inv_fun = e.symm | rfl | lemma | linear_equiv.inv_fun_eq_symm | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_to_equiv_symm : ⇑e.to_equiv.symm = e.symm | rfl | lemma | linear_equiv.coe_to_equiv_symm | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
trans : M₁ ≃ₛₗ[σ₁₃] M₃ | { .. e₂₃.to_linear_map.comp e₁₂.to_linear_map,
.. e₁₂.to_equiv.trans e₂₃.to_equiv } | def | linear_equiv.trans | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_to_add_equiv : ⇑(e.to_add_equiv) = e | rfl | lemma | linear_equiv.coe_to_add_equiv | algebra.module | src/algebra/module/equiv.lean | [
"algebra.module.linear_map"
] | [] | 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.