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 |
|---|---|---|---|---|---|---|---|---|---|---|
non_unital_alg_hom_ext' [distrib_mul_action k A]
{φ₁ φ₂ : add_monoid_algebra k G →ₙₐ[k] A}
(h : φ₁.to_mul_hom.comp (of_magma k G) = φ₂.to_mul_hom.comp (of_magma k G)) : φ₁ = φ₂ | @monoid_algebra.non_unital_alg_hom_ext' k (multiplicative G) _ _ _ _ _ φ₁ φ₂ h | lemma | add_monoid_algebra.non_unital_alg_hom_ext' | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid_algebra",
"distrib_mul_action",
"monoid_algebra.non_unital_alg_hom_ext'",
"multiplicative"
] | See note [partially-applied ext lemmas]. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
lift_magma [module k A] [is_scalar_tower k A A] [smul_comm_class k A A] :
(multiplicative G →ₙ* A) ≃ (add_monoid_algebra k G →ₙₐ[k] A) | { to_fun := λ f, { to_fun := λ a, sum a (λ m t, t • f (multiplicative.of_add m)),
.. (monoid_algebra.lift_magma k f : _)},
inv_fun := λ F, F.to_mul_hom.comp (of_magma k G),
.. (monoid_algebra.lift_magma k : (multiplicative G →ₙ* A) ≃ (_ →ₙₐ[k] A)) } | def | add_monoid_algebra.lift_magma | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid_algebra",
"inv_fun",
"is_scalar_tower",
"module",
"monoid_algebra.lift_magma",
"multiplicative",
"multiplicative.of_add",
"smul_comm_class"
] | The functor `G ↦ add_monoid_algebra k G`, from the category of magmas to the category of
non-unital, non-associative algebras over `k` is adjoint to the forgetful functor in the other
direction. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
single_zero_ring_hom [semiring k] [add_monoid G] : k →+* add_monoid_algebra k G | { map_one' := rfl,
map_mul' := λ x y, by rw [single_add_hom, single_mul_single, zero_add],
..finsupp.single_add_hom 0} | def | add_monoid_algebra.single_zero_ring_hom | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid",
"add_monoid_algebra",
"finsupp.single_add_hom",
"semiring"
] | `finsupp.single 0` as a `ring_hom` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
ring_hom_ext {R} [semiring k] [add_monoid G] [semiring R]
{f g : add_monoid_algebra k G →+* R} (h₀ : ∀ b, f (single 0 b) = g (single 0 b))
(h_of : ∀ a, f (single a 1) = g (single a 1)) : f = g | @monoid_algebra.ring_hom_ext k (multiplicative G) R _ _ _ _ _ h₀ h_of | lemma | add_monoid_algebra.ring_hom_ext | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid",
"add_monoid_algebra",
"monoid_algebra.ring_hom_ext",
"multiplicative",
"ring_hom_ext",
"semiring"
] | If two ring homomorphisms from `add_monoid_algebra k G` are equal on all `single a 1`
and `single 0 b`, then they are equal. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
ring_hom_ext' {R} [semiring k] [add_monoid G] [semiring R]
{f g : add_monoid_algebra k G →+* R}
(h₁ : f.comp single_zero_ring_hom = g.comp single_zero_ring_hom)
(h_of : (f : add_monoid_algebra k G →* R).comp (of k G) =
(g : add_monoid_algebra k G →* R).comp (of k G)) :
f = g | ring_hom_ext (ring_hom.congr_fun h₁) (monoid_hom.congr_fun h_of) | lemma | add_monoid_algebra.ring_hom_ext' | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid",
"add_monoid_algebra",
"monoid_hom.congr_fun",
"ring_hom.congr_fun",
"ring_hom_ext",
"semiring"
] | If two ring homomorphisms from `add_monoid_algebra k G` are equal on all `single a 1`
and `single 0 b`, then they are equal.
See note [partially-applied ext lemmas]. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
op_ring_equiv [add_comm_monoid G] :
(add_monoid_algebra k G)ᵐᵒᵖ ≃+* add_monoid_algebra kᵐᵒᵖ G | { map_mul' := begin
dsimp only [add_equiv.to_fun_eq_coe, ←add_equiv.coe_to_add_monoid_hom],
rw add_monoid_hom.map_mul_iff,
ext i r i' r' : 6,
dsimp,
simp only [map_range_single, single_mul_single, ←op_mul, add_comm]
end,
..mul_opposite.op_add_equiv.symm.trans
(finsupp.map_range.add_equiv (mu... | def | add_monoid_algebra.op_ring_equiv | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_comm_monoid",
"add_monoid_algebra",
"add_monoid_hom.map_mul_iff",
"finsupp.map_range.add_equiv",
"mul_opposite.op_add_equiv"
] | The opposite of an `add_monoid_algebra R I` is ring equivalent to
the `add_monoid_algebra Rᵐᵒᵖ I` over the opposite ring, taking elements to their opposite. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
op_ring_equiv_single [add_comm_monoid G] (r : k) (x : G) :
add_monoid_algebra.op_ring_equiv (op (single x r)) = single x (op r) | by simp | lemma | add_monoid_algebra.op_ring_equiv_single | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_comm_monoid",
"add_monoid_algebra.op_ring_equiv"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
op_ring_equiv_symm_single [add_comm_monoid G] (r : kᵐᵒᵖ) (x : Gᵐᵒᵖ) :
add_monoid_algebra.op_ring_equiv.symm (single x r) = op (single x r.unop) | by simp | lemma | add_monoid_algebra.op_ring_equiv_symm_single | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_comm_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_zero_alg_hom [comm_semiring R] [semiring k] [algebra R k] [add_monoid G] :
k →ₐ[R] add_monoid_algebra k G | { commutes' := λ r, by { ext, simp, refl, }, ..single_zero_ring_hom} | def | add_monoid_algebra.single_zero_alg_hom | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid",
"add_monoid_algebra",
"algebra",
"comm_semiring",
"semiring"
] | `finsupp.single 0` as a `alg_hom` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
coe_algebra_map [comm_semiring R] [semiring k] [algebra R k] [add_monoid G] :
(algebra_map R (add_monoid_algebra k G) : R → add_monoid_algebra k G) =
single 0 ∘ (algebra_map R k) | rfl | lemma | add_monoid_algebra.coe_algebra_map | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid",
"add_monoid_algebra",
"algebra",
"algebra_map",
"comm_semiring",
"semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_nc_alg_hom (f : A →ₐ[k] B) (g : multiplicative G →* B)
(h_comm : ∀ x y, commute (f x) (g y)) :
add_monoid_algebra A G →ₐ[k] B | { to_fun := lift_nc_ring_hom (f : A →+* B) g h_comm,
commutes' := by simp [lift_nc_ring_hom],
..(lift_nc_ring_hom (f : A →+* B) g h_comm)} | def | add_monoid_algebra.lift_nc_alg_hom | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid_algebra",
"commute",
"multiplicative"
] | `lift_nc_ring_hom` as a `alg_hom`, for when `f` is an `alg_hom` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
alg_hom_ext ⦃φ₁ φ₂ : add_monoid_algebra k G →ₐ[k] A⦄
(h : ∀ x, φ₁ (single x 1) = φ₂ (single x 1)) : φ₁ = φ₂ | @monoid_algebra.alg_hom_ext k (multiplicative G) _ _ _ _ _ _ _ h | lemma | add_monoid_algebra.alg_hom_ext | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid_algebra",
"monoid_algebra.alg_hom_ext",
"multiplicative"
] | A `k`-algebra homomorphism from `monoid_algebra k G` is uniquely defined by its
values on the functions `single a 1`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
alg_hom_ext' ⦃φ₁ φ₂ : add_monoid_algebra k G →ₐ[k] A⦄
(h : (φ₁ : add_monoid_algebra k G →* A).comp (of k G) =
(φ₂ : add_monoid_algebra k G →* A).comp (of k G)) : φ₁ = φ₂ | alg_hom_ext $ monoid_hom.congr_fun h | lemma | add_monoid_algebra.alg_hom_ext' | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid_algebra",
"monoid_hom.congr_fun"
] | See note [partially-applied ext lemmas]. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
lift : (multiplicative G →* A) ≃ (add_monoid_algebra k G →ₐ[k] A) | { inv_fun := λ f, (f : add_monoid_algebra k G →* A).comp (of k G),
to_fun := λ F,
{ to_fun := lift_nc_alg_hom (algebra.of_id k A) F $ λ _ _, algebra.commutes _ _,
.. @monoid_algebra.lift k (multiplicative G) _ _ A _ _ F},
.. @monoid_algebra.lift k (multiplicative G) _ _ A _ _ } | def | add_monoid_algebra.lift | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid_algebra",
"algebra.commutes",
"algebra.of_id",
"inv_fun",
"lift",
"monoid_algebra.lift",
"multiplicative"
] | Any monoid homomorphism `G →* A` can be lifted to an algebra homomorphism
`monoid_algebra k G →ₐ[k] A`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
lift_apply' (F : multiplicative G →* A) (f : monoid_algebra k G) :
lift k G A F f = f.sum (λ a b, (algebra_map k A b) * F (multiplicative.of_add a)) | rfl | lemma | add_monoid_algebra.lift_apply' | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"algebra_map",
"lift",
"monoid_algebra",
"multiplicative",
"multiplicative.of_add"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_apply (F : multiplicative G →* A) (f : monoid_algebra k G) :
lift k G A F f = f.sum (λ a b, b • F (multiplicative.of_add a)) | by simp only [lift_apply', algebra.smul_def] | lemma | add_monoid_algebra.lift_apply | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"algebra.smul_def",
"lift",
"monoid_algebra",
"multiplicative",
"multiplicative.of_add"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_def (F : multiplicative G →* A) :
⇑(lift k G A F) = lift_nc ((algebra_map k A : k →+* A) : k →+ A) F | rfl | lemma | add_monoid_algebra.lift_def | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"algebra_map",
"lift",
"multiplicative"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_symm_apply (F : add_monoid_algebra k G →ₐ[k] A) (x : multiplicative G) :
(lift k G A).symm F x = F (single x.to_add 1) | rfl | lemma | add_monoid_algebra.lift_symm_apply | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid_algebra",
"lift",
"multiplicative"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_of (F : multiplicative G →* A) (x : multiplicative G) :
lift k G A F (of k G x) = F x | by rw [of_apply, ← lift_symm_apply, equiv.symm_apply_apply] | lemma | add_monoid_algebra.lift_of | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"equiv.symm_apply_apply",
"lift",
"multiplicative"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_single (F : multiplicative G →* A) (a b) :
lift k G A F (single a b) = b • F (multiplicative.of_add a) | by rw [lift_def, lift_nc_single, algebra.smul_def, ring_hom.coe_add_monoid_hom] | lemma | add_monoid_algebra.lift_single | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"algebra.smul_def",
"lift",
"multiplicative",
"multiplicative.of_add",
"ring_hom.coe_add_monoid_hom"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_unique' (F : add_monoid_algebra k G →ₐ[k] A) :
F = lift k G A ((F : add_monoid_algebra k G →* A).comp (of k G)) | ((lift k G A).apply_symm_apply F).symm | lemma | add_monoid_algebra.lift_unique' | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid_algebra",
"lift"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_unique (F : add_monoid_algebra k G →ₐ[k] A) (f : monoid_algebra k G) :
F f = f.sum (λ a b, b • F (single a 1)) | by conv_lhs { rw lift_unique' F, simp [lift_apply] } | lemma | add_monoid_algebra.lift_unique | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid_algebra",
"lift_unique",
"monoid_algebra"
] | Decomposition of a `k`-algebra homomorphism from `monoid_algebra k G` by
its values on `F (single a 1)`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
alg_hom_ext_iff {φ₁ φ₂ : add_monoid_algebra k G →ₐ[k] A} :
(∀ x, φ₁ (finsupp.single x 1) = φ₂ (finsupp.single x 1)) ↔ φ₁ = φ₂ | ⟨λ h, alg_hom_ext h, by rintro rfl _; refl⟩ | lemma | add_monoid_algebra.alg_hom_ext_iff | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid_algebra",
"finsupp.single"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_single [comm_semiring k] [add_comm_monoid G]
{s : finset ι} {a : ι → G} {b : ι → k} :
(∏ i in s, single (a i) (b i)) = single (∑ i in s, a i) (∏ i in s, b i) | finset.cons_induction_on s rfl $ λ a s has ih, by rw [prod_cons has, ih,
single_mul_single, sum_cons has, prod_cons has] | lemma | add_monoid_algebra.prod_single | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_comm_monoid",
"comm_semiring",
"finset",
"finset.cons_induction_on",
"ih"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_domain_algebra_map {A H F : Type*} [comm_semiring k] [semiring A]
[algebra k A] [add_monoid G] [add_monoid H] [add_monoid_hom_class F G H] (f : F) (r : k) :
map_domain f (algebra_map k (add_monoid_algebra A G) r) =
algebra_map k (add_monoid_algebra A H) r | by simp only [function.comp_app, map_domain_single, add_monoid_algebra.coe_algebra_map, map_zero] | lemma | add_monoid_algebra.map_domain_algebra_map | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid",
"add_monoid_algebra",
"add_monoid_algebra.coe_algebra_map",
"add_monoid_hom_class",
"algebra",
"algebra_map",
"comm_semiring",
"semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_domain_non_unital_alg_hom (k A : Type*) [comm_semiring k] [semiring A] [algebra k A]
{G H F : Type*} [has_add G] [has_add H] [add_hom_class F G H] (f : F) :
add_monoid_algebra A G →ₙₐ[k] add_monoid_algebra A H | { map_mul' := λ x y, map_domain_mul f x y,
map_smul' := λ r x, map_domain_smul r x,
..(finsupp.map_domain.add_monoid_hom f : monoid_algebra A G →+ monoid_algebra A H) } | def | add_monoid_algebra.map_domain_non_unital_alg_hom | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_hom_class",
"add_monoid_algebra",
"algebra",
"comm_semiring",
"finsupp.map_domain.add_monoid_hom",
"monoid_algebra",
"semiring"
] | If `f : G → H` is a homomorphism between two additive magmas, then `finsupp.map_domain f` is a
non-unital algebra homomorphism between their additive magma algebras. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
map_domain_alg_hom (k A : Type*) [comm_semiring k] [semiring A] [algebra k A]
[add_monoid G] {H F : Type*} [add_monoid H] [add_monoid_hom_class F G H] (f : F) :
add_monoid_algebra A G →ₐ[k] add_monoid_algebra A H | { commutes' := map_domain_algebra_map f,
..map_domain_ring_hom A f} | def | add_monoid_algebra.map_domain_alg_hom | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid",
"add_monoid_algebra",
"add_monoid_hom_class",
"algebra",
"comm_semiring",
"semiring"
] | If `f : G → H` is an additive homomorphism between two additive monoids, then
`finsupp.map_domain f` is an algebra homomorphism between their add monoid algebras. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
add_monoid_algebra.to_multiplicative_alg_equiv [semiring k] [algebra R k] [add_monoid G] :
add_monoid_algebra k G ≃ₐ[R] monoid_algebra k (multiplicative G) | { commutes' := λ r, by simp [add_monoid_algebra.to_multiplicative],
..add_monoid_algebra.to_multiplicative k G } | def | add_monoid_algebra.to_multiplicative_alg_equiv | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid",
"add_monoid_algebra",
"add_monoid_algebra.to_multiplicative",
"algebra",
"monoid_algebra",
"multiplicative",
"semiring"
] | The algebra equivalence between `add_monoid_algebra` and `monoid_algebra` in terms of
`multiplicative`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
monoid_algebra.to_additive_alg_equiv [semiring k] [algebra R k] [monoid G] :
monoid_algebra k G ≃ₐ[R] add_monoid_algebra k (additive G) | { commutes' := λ r, by simp [monoid_algebra.to_additive],
..monoid_algebra.to_additive k G } | def | monoid_algebra.to_additive_alg_equiv | algebra.monoid_algebra | src/algebra/monoid_algebra/basic.lean | [
"algebra.algebra.equiv",
"algebra.big_operators.finsupp",
"algebra.hom.non_unital_alg",
"algebra.module.big_operators",
"linear_algebra.finsupp"
] | [
"add_monoid_algebra",
"additive",
"algebra",
"monoid",
"monoid_algebra",
"monoid_algebra.to_additive",
"semiring"
] | The algebra equivalence between `monoid_algebra` and `add_monoid_algebra` in terms of
`additive`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
sup_support_add_le : (f + g).support.sup degb ≤ (f.support.sup degb) ⊔ (g.support.sup degb) | (finset.sup_mono finsupp.support_add).trans_eq finset.sup_union | lemma | add_monoid_algebra.sup_support_add_le | algebra.monoid_algebra | src/algebra/monoid_algebra/degree.lean | [
"algebra.monoid_algebra.support"
] | [
"finset.sup_mono",
"finset.sup_union",
"finsupp.support_add"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
le_inf_support_add : f.support.inf degt ⊓ g.support.inf degt ≤ (f + g).support.inf degt | sup_support_add_le (λ a : A, order_dual.to_dual (degt a)) f g | lemma | add_monoid_algebra.le_inf_support_add | algebra.monoid_algebra | src/algebra/monoid_algebra/degree.lean | [
"algebra.monoid_algebra.support"
] | [
"order_dual.to_dual"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sup_support_mul_le {degb : A → B} (degbm : ∀ {a b}, degb (a + b) ≤ degb a + degb b)
(f g : add_monoid_algebra R A) :
(f * g).support.sup degb ≤ f.support.sup degb + g.support.sup degb | begin
refine (finset.sup_mono $ support_mul _ _).trans _,
simp_rw [finset.sup_bUnion, finset.sup_singleton],
refine (finset.sup_le $ λ fd fds, finset.sup_le $ λ gd gds, degbm.trans $ add_le_add _ _);
exact finset.le_sup ‹_›,
end | lemma | add_monoid_algebra.sup_support_mul_le | algebra.monoid_algebra | src/algebra/monoid_algebra/degree.lean | [
"algebra.monoid_algebra.support"
] | [
"add_monoid_algebra",
"finset.le_sup",
"finset.sup_bUnion",
"finset.sup_mono",
"finset.sup_singleton"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
le_inf_support_mul {degt : A → T} (degtm : ∀ {a b}, degt a + degt b ≤ degt (a + b))
(f g : add_monoid_algebra R A) :
f.support.inf degt + g.support.inf degt ≤ (f * g).support.inf degt | order_dual.of_dual_le_of_dual.mpr $
sup_support_mul_le (λ a b, order_dual.of_dual_le_of_dual.mp degtm) f g | lemma | add_monoid_algebra.le_inf_support_mul | algebra.monoid_algebra | src/algebra/monoid_algebra/degree.lean | [
"algebra.monoid_algebra.support"
] | [
"add_monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sup_support_list_prod_le (degb0 : degb 0 ≤ 0)
(degbm : ∀ a b, degb (a + b) ≤ degb a + degb b) :
∀ l : list (add_monoid_algebra R A),
l.prod.support.sup degb ≤ (l.map (λ f : add_monoid_algebra R A, f.support.sup degb)).sum | | [] := begin
rw [list.map_nil, finset.sup_le_iff, list.prod_nil, list.sum_nil],
exact λ a ha, by rwa [finset.mem_singleton.mp (finsupp.support_single_subset ha)]
end
| (f::fs) := begin
rw [list.prod_cons, list.map_cons, list.sum_cons],
exact (sup_support_mul_le degbm _ _).trans (add_le_add_left (sup_... | lemma | add_monoid_algebra.sup_support_list_prod_le | algebra.monoid_algebra | src/algebra/monoid_algebra/degree.lean | [
"algebra.monoid_algebra.support"
] | [
"add_monoid_algebra",
"finset.sup_le_iff",
"finsupp.support_single_subset",
"list.map_nil",
"list.prod_cons",
"list.prod_nil"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
le_inf_support_list_prod (degt0 : 0 ≤ degt 0) (degtm : ∀ a b, degt a + degt b ≤ degt (a + b))
(l : list (add_monoid_algebra R A)) :
(l.map (λ f : add_monoid_algebra R A, f.support.inf degt)).sum ≤ l.prod.support.inf degt | order_dual.of_dual_le_of_dual.mpr $ sup_support_list_prod_le
(order_dual.of_dual_le_of_dual.mp degt0) (λ a b, order_dual.of_dual_le_of_dual.mp (degtm _ _)) l | lemma | add_monoid_algebra.le_inf_support_list_prod | algebra.monoid_algebra | src/algebra/monoid_algebra/degree.lean | [
"algebra.monoid_algebra.support"
] | [
"add_monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sup_support_pow_le (degb0 : degb 0 ≤ 0) (degbm : ∀ a b, degb (a + b) ≤ degb a + degb b)
(n : ℕ) (f : add_monoid_algebra R A) :
(f ^ n).support.sup degb ≤ n • (f.support.sup degb) | begin
rw [← list.prod_replicate, ←list.sum_replicate],
refine (sup_support_list_prod_le degb0 degbm _).trans_eq _,
rw list.map_replicate,
end | lemma | add_monoid_algebra.sup_support_pow_le | algebra.monoid_algebra | src/algebra/monoid_algebra/degree.lean | [
"algebra.monoid_algebra.support"
] | [
"add_monoid_algebra",
"list.map_replicate",
"list.prod_replicate"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
le_inf_support_pow (degt0 : 0 ≤ degt 0) (degtm : ∀ a b, degt a + degt b ≤ degt (a + b))
(n : ℕ) (f : add_monoid_algebra R A) :
n • (f.support.inf degt) ≤ (f ^ n).support.inf degt | order_dual.of_dual_le_of_dual.mpr $ sup_support_pow_le (order_dual.of_dual_le_of_dual.mp degt0)
(λ a b, order_dual.of_dual_le_of_dual.mp (degtm _ _)) n f | lemma | add_monoid_algebra.le_inf_support_pow | algebra.monoid_algebra | src/algebra/monoid_algebra/degree.lean | [
"algebra.monoid_algebra.support"
] | [
"add_monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sup_support_multiset_prod_le
(degb0 : degb 0 ≤ 0) (degbm : ∀ a b, degb (a + b) ≤ degb a + degb b)
(m : multiset (add_monoid_algebra R A)) :
m.prod.support.sup degb ≤ (m.map (λ f : add_monoid_algebra R A, f.support.sup degb)).sum | begin
induction m using quot.induction_on,
rw [multiset.quot_mk_to_coe'', multiset.coe_map, multiset.coe_sum, multiset.coe_prod],
exact sup_support_list_prod_le degb0 degbm m,
end | lemma | add_monoid_algebra.sup_support_multiset_prod_le | algebra.monoid_algebra | src/algebra/monoid_algebra/degree.lean | [
"algebra.monoid_algebra.support"
] | [
"add_monoid_algebra",
"multiset",
"multiset.coe_map",
"multiset.coe_prod",
"multiset.quot_mk_to_coe''"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
le_inf_support_multiset_prod
(degt0 : 0 ≤ degt 0) (degtm : ∀ a b, degt a + degt b ≤ degt (a + b))
(m : multiset (add_monoid_algebra R A)) :
(m.map (λ f : add_monoid_algebra R A, f.support.inf degt)).sum ≤ m.prod.support.inf degt | order_dual.of_dual_le_of_dual.mpr $
sup_support_multiset_prod_le (order_dual.of_dual_le_of_dual.mp degt0)
(λ a b, order_dual.of_dual_le_of_dual.mp (degtm _ _)) m | lemma | add_monoid_algebra.le_inf_support_multiset_prod | algebra.monoid_algebra | src/algebra/monoid_algebra/degree.lean | [
"algebra.monoid_algebra.support"
] | [
"add_monoid_algebra",
"multiset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sup_support_finset_prod_le
(degb0 : degb 0 ≤ 0) (degbm : ∀ a b, degb (a + b) ≤ degb a + degb b)
(s : finset ι) (f : ι → add_monoid_algebra R A) :
(∏ i in s, f i).support.sup degb ≤ ∑ i in s, (f i).support.sup degb | (sup_support_multiset_prod_le degb0 degbm _).trans_eq $ congr_arg _ $ multiset.map_map _ _ _ | lemma | add_monoid_algebra.sup_support_finset_prod_le | algebra.monoid_algebra | src/algebra/monoid_algebra/degree.lean | [
"algebra.monoid_algebra.support"
] | [
"add_monoid_algebra",
"finset",
"multiset.map_map"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
le_inf_support_finset_prod
(degt0 : 0 ≤ degt 0) (degtm : ∀ a b, degt a + degt b ≤ degt (a + b))
(s : finset ι) (f : ι → add_monoid_algebra R A) :
∑ i in s, (f i).support.inf degt ≤ (∏ i in s, f i).support.inf degt | le_of_eq_of_le (by rw [multiset.map_map]; refl) (le_inf_support_multiset_prod degt0 degtm _) | lemma | add_monoid_algebra.le_inf_support_finset_prod | algebra.monoid_algebra | src/algebra/monoid_algebra/degree.lean | [
"algebra.monoid_algebra.support"
] | [
"add_monoid_algebra",
"finset",
"le_of_eq_of_le",
"multiset.map_map"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
div_of (x : add_monoid_algebra k G) (g : G) : add_monoid_algebra k G | -- note: comapping by `+ g` has the effect of subtracting `g` from every element in the support, and
-- discarding the elements of the support from which `g` can't be subtracted. If `G` is an additive
-- group, such as `ℤ` when used for `laurent_polynomial`, then no discarding occurs.
@finsupp.comap_domain.add_monoid_h... | def | add_monoid_algebra.div_of | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra",
"finsupp.comap_domain.add_monoid_hom"
] | Divide by `of' k G g`, discarding terms not divisible by this. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
div_of_apply (g : G) (x : add_monoid_algebra k G) (g' : G) :
(x /ᵒᶠ g) g' = x (g + g') | rfl | lemma | add_monoid_algebra.div_of_apply | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
support_div_of (g : G) (x : add_monoid_algebra k G) :
(x /ᵒᶠ g).support = x.support.preimage ((+) g)
(function.injective.inj_on
(add_right_injective g) _) | rfl | lemma | add_monoid_algebra.support_div_of | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
zero_div_of (g : G) : (0 : add_monoid_algebra k G) /ᵒᶠ g = 0 | map_zero _ | lemma | add_monoid_algebra.zero_div_of | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
div_of_zero (x : add_monoid_algebra k G) : x /ᵒᶠ 0 = x | by { ext, simp only [add_monoid_algebra.div_of_apply, zero_add] } | lemma | add_monoid_algebra.div_of_zero | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra",
"add_monoid_algebra.div_of_apply"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
add_div_of (x y : add_monoid_algebra k G) (g : G) : (x + y) /ᵒᶠ g = x /ᵒᶠ g + y /ᵒᶠ g | map_add _ _ _ | lemma | add_monoid_algebra.add_div_of | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
div_of_add (x : add_monoid_algebra k G) (a b : G) :
x /ᵒᶠ (a + b) = (x /ᵒᶠ a) /ᵒᶠ b | by { ext, simp only [add_monoid_algebra.div_of_apply, add_assoc] } | lemma | add_monoid_algebra.div_of_add | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra",
"add_monoid_algebra.div_of_apply"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
div_of_hom : multiplicative G →* add_monoid.End (add_monoid_algebra k G) | { to_fun := λ g,
{ to_fun := λ x, div_of x g.to_add,
map_zero' := zero_div_of _,
map_add' := λ x y, add_div_of x y g.to_add },
map_one' := add_monoid_hom.ext div_of_zero,
map_mul' := λ g₁ g₂, add_monoid_hom.ext $ λ x,
(congr_arg _ (add_comm g₁.to_add g₂.to_add)).trans (div_of_add _ _ _) } | def | add_monoid_algebra.div_of_hom | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid.End",
"add_monoid_algebra",
"multiplicative"
] | A bundled version of `add_monoid_algebra.div_of`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
of'_mul_div_of (a : G) (x : add_monoid_algebra k G) :
(of' k G a * x) /ᵒᶠ a = x | begin
ext b,
rw [add_monoid_algebra.div_of_apply, of'_apply, single_mul_apply_aux, one_mul],
intro c,
exact add_right_inj _,
end | lemma | add_monoid_algebra.of'_mul_div_of | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra",
"add_monoid_algebra.div_of_apply",
"one_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_of'_div_of (x : add_monoid_algebra k G) (a : G) :
(x * of' k G a) /ᵒᶠ a = x | begin
ext b,
rw [add_monoid_algebra.div_of_apply, of'_apply, mul_single_apply_aux, mul_one],
intro c,
rw add_comm,
exact add_right_inj _,
end | lemma | add_monoid_algebra.mul_of'_div_of | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra",
"add_monoid_algebra.div_of_apply",
"mul_one"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of'_div_of (a : G) : (of' k G a) /ᵒᶠ a = 1 | by simpa only [one_mul] using mul_of'_div_of (1 : add_monoid_algebra k G) a | lemma | add_monoid_algebra.of'_div_of | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra",
"one_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mod_of (x : add_monoid_algebra k G) (g : G) : add_monoid_algebra k G | x.filter (λ g₁, ¬∃ g₂, g₁ = g + g₂) | def | add_monoid_algebra.mod_of | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra"
] | The remainder upon division by `of' k G g`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mod_of_apply_of_not_exists_add (x : add_monoid_algebra k G) (g : G) (g' : G)
(h : ¬∃ d, g' = g + d) :
(x %ᵒᶠ g) g' = x g' | finsupp.filter_apply_pos _ _ h | lemma | add_monoid_algebra.mod_of_apply_of_not_exists_add | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra",
"finsupp.filter_apply_pos"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mod_of_apply_of_exists_add (x : add_monoid_algebra k G) (g : G) (g' : G)
(h : ∃ d, g' = g + d) :
(x %ᵒᶠ g) g' = 0 | finsupp.filter_apply_neg _ _ $ by rwa [not_not] | lemma | add_monoid_algebra.mod_of_apply_of_exists_add | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra",
"finsupp.filter_apply_neg",
"not_not"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mod_of_apply_add_self (x : add_monoid_algebra k G) (g : G) (d : G) :
(x %ᵒᶠ g) (d + g) = 0 | mod_of_apply_of_exists_add _ _ _ ⟨_, add_comm _ _⟩ | lemma | add_monoid_algebra.mod_of_apply_add_self | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mod_of_apply_self_add (x : add_monoid_algebra k G) (g : G) (d : G) :
(x %ᵒᶠ g) (g + d) = 0 | mod_of_apply_of_exists_add _ _ _ ⟨_, rfl⟩ | lemma | add_monoid_algebra.mod_of_apply_self_add | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of'_mul_mod_of (g : G) (x : add_monoid_algebra k G) :
(of' k G g * x) %ᵒᶠ g = 0 | begin
ext g',
rw finsupp.zero_apply,
obtain ⟨d, rfl⟩ | h := em (∃ d, g' = g + d),
{ rw mod_of_apply_self_add },
{ rw [mod_of_apply_of_not_exists_add _ _ _ h, of'_apply,
single_mul_apply_of_not_exists_add _ _ h] },
end | lemma | add_monoid_algebra.of'_mul_mod_of | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra",
"em",
"finsupp.zero_apply"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_of'_mod_of (x : add_monoid_algebra k G) (g : G) :
(x * of' k G g) %ᵒᶠ g = 0 | begin
ext g',
rw finsupp.zero_apply,
obtain ⟨d, rfl⟩ | h := em (∃ d, g' = g + d),
{ rw mod_of_apply_self_add },
{ rw [mod_of_apply_of_not_exists_add _ _ _ h, of'_apply, mul_single_apply_of_not_exists_add],
simpa only [add_comm] using h },
end | lemma | add_monoid_algebra.mul_of'_mod_of | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra",
"em",
"finsupp.zero_apply"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of'_mod_of (g : G) : of' k G g %ᵒᶠ g = 0 | by simpa only [one_mul] using mul_of'_mod_of (1 : add_monoid_algebra k G) g | lemma | add_monoid_algebra.of'_mod_of | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra",
"one_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
div_of_add_mod_of (x : add_monoid_algebra k G) (g : G) :
of' k G g * (x /ᵒᶠ g) + x %ᵒᶠ g = x | begin
ext g',
simp_rw [finsupp.add_apply],
obtain ⟨d, rfl⟩ | h := em (∃ d, g' = g + d),
swap,
{ rw [mod_of_apply_of_not_exists_add _ _ _ h, of'_apply, single_mul_apply_of_not_exists_add _ _ h,
zero_add] },
{ rw [mod_of_apply_self_add, add_zero],
rw [of'_apply, single_mul_apply_aux _ _ _, one_mul, ... | lemma | add_monoid_algebra.div_of_add_mod_of | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra",
"em",
"finsupp.add_apply",
"one_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mod_of_add_div_of (x : add_monoid_algebra k G) (g : G) :
x %ᵒᶠ g + of' k G g * (x /ᵒᶠ g) = x | by rw [add_comm, div_of_add_mod_of] | lemma | add_monoid_algebra.mod_of_add_div_of | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of'_dvd_iff_mod_of_eq_zero {x : add_monoid_algebra k G} {g : G} :
of' k G g ∣ x ↔ x %ᵒᶠ g = 0 | begin
split,
{ rintro ⟨x, rfl⟩,
rw of'_mul_mod_of },
{ intro h,
rw [←div_of_add_mod_of x g, h, add_zero],
exact dvd_mul_right _ _ },
end | lemma | add_monoid_algebra.of'_dvd_iff_mod_of_eq_zero | algebra.monoid_algebra | src/algebra/monoid_algebra/division.lean | [
"algebra.monoid_algebra.basic",
"data.finsupp.order"
] | [
"add_monoid_algebra",
"dvd_mul_right"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
grade_by (f : M → ι) (i : ι) : submodule R (add_monoid_algebra R M) | { carrier := {a | ∀ m, m ∈ a.support → f m = i },
zero_mem' := set.empty_subset _,
add_mem' := λ a b ha hb m h,
or.rec_on (finset.mem_union.mp (finsupp.support_add h)) (ha m) (hb m),
smul_mem' := λ a m h, set.subset.trans finsupp.support_smul h } | abbreviation | add_monoid_algebra.grade_by | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"add_monoid_algebra",
"finsupp.support_add",
"finsupp.support_smul",
"set.empty_subset",
"set.subset.trans",
"submodule"
] | The submodule corresponding to each grade given by the degree function `f`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
grade (m : M) : submodule R (add_monoid_algebra R M) | grade_by R id m | abbreviation | add_monoid_algebra.grade | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"add_monoid_algebra",
"grade",
"submodule"
] | The submodule corresponding to each grade. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
grade_by_id : grade_by R (id : M → M) = grade R | by refl | lemma | add_monoid_algebra.grade_by_id | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"grade"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_grade_by_iff (f : M → ι) (i : ι) (a : add_monoid_algebra R M) :
a ∈ grade_by R f i ↔ (a.support : set M) ⊆ f ⁻¹' {i} | by refl | lemma | add_monoid_algebra.mem_grade_by_iff | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"add_monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_grade_iff (m : M) (a : add_monoid_algebra R M) : a ∈ grade R m ↔ a.support ⊆ {m} | begin
rw [← finset.coe_subset, finset.coe_singleton],
refl
end | lemma | add_monoid_algebra.mem_grade_iff | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"add_monoid_algebra",
"finset.coe_singleton",
"finset.coe_subset",
"grade"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_grade_iff' (m : M) (a : add_monoid_algebra R M) :
a ∈ grade R m ↔
a ∈ ((finsupp.lsingle m : R →ₗ[R] (M →₀ R)).range : submodule R (add_monoid_algebra R M)) | begin
rw [mem_grade_iff, finsupp.support_subset_singleton'],
apply exists_congr,
intros r,
split; exact eq.symm
end | lemma | add_monoid_algebra.mem_grade_iff' | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"add_monoid_algebra",
"finsupp.lsingle",
"finsupp.support_subset_singleton'",
"grade",
"submodule"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
grade_eq_lsingle_range (m : M) : grade R m = (finsupp.lsingle m : R →ₗ[R] (M →₀ R)).range | submodule.ext (mem_grade_iff' R m) | lemma | add_monoid_algebra.grade_eq_lsingle_range | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"finsupp.lsingle",
"grade",
"submodule.ext"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_mem_grade_by {R} [comm_semiring R] (f : M → ι) (m : M) (r : R) :
finsupp.single m r ∈ grade_by R f (f m) | begin
intros x hx,
rw finset.mem_singleton.mp (finsupp.support_single_subset hx),
end | lemma | add_monoid_algebra.single_mem_grade_by | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"comm_semiring",
"finsupp.single",
"finsupp.support_single_subset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_mem_grade {R} [comm_semiring R] (i : M) (r : R) : finsupp.single i r ∈ grade R i | single_mem_grade_by _ _ _ | lemma | add_monoid_algebra.single_mem_grade | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"comm_semiring",
"finsupp.single",
"grade"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
grade_by.graded_monoid [add_monoid M] [add_monoid ι] [comm_semiring R] (f : M →+ ι) :
set_like.graded_monoid (grade_by R f : ι → submodule R (add_monoid_algebra R M)) | { one_mem := λ m h, begin
rw one_def at h,
by_cases H : (1 : R) = (0 : R),
{ rw [H , finsupp.single_zero] at h,
exfalso,
exact h },
{ rw [finsupp.support_single_ne_zero _ H, finset.mem_singleton] at h,
rw [h, add_monoid_hom.map_zero] }
end,
mul_mem := λ i j a b ha hb c hc, begin
... | instance | add_monoid_algebra.grade_by.graded_monoid | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"add_monoid",
"add_monoid_algebra",
"comm_semiring",
"finset.mem_bUnion",
"finset.mem_singleton",
"finsupp.single_zero",
"finsupp.support_single_ne_zero",
"set_like.graded_monoid",
"submodule"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
grade.graded_monoid [add_monoid M] [comm_semiring R] :
set_like.graded_monoid (grade R : M → submodule R (add_monoid_algebra R M)) | by apply grade_by.graded_monoid (add_monoid_hom.id _) | instance | add_monoid_algebra.grade.graded_monoid | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"add_monoid",
"add_monoid_algebra",
"comm_semiring",
"grade",
"set_like.graded_monoid",
"submodule"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
decompose_aux : add_monoid_algebra R M →ₐ[R] ⨁ i : ι, grade_by R f i | add_monoid_algebra.lift R M _
{ to_fun := λ m, direct_sum.of (λ i : ι, grade_by R f i) (f m.to_add)
⟨finsupp.single m.to_add 1, single_mem_grade_by _ _ _⟩,
map_one' := direct_sum.of_eq_of_graded_monoid_eq (by congr' 2; try {ext};
simp only [submodule.mem_to_add_submonoid, to_add_one, add_monoid_hom.map_zero])... | def | add_monoid_algebra.decompose_aux | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"add_monoid_algebra",
"add_monoid_algebra.lift",
"direct_sum.of",
"direct_sum.of_eq_of_graded_monoid_eq",
"direct_sum.of_mul_of",
"one_mul",
"submodule.mem_to_add_submonoid",
"to_add_mul",
"to_add_one"
] | Auxiliary definition; the canonical grade decomposition, used to provide
`direct_sum.decompose`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
decompose_aux_single (m : M) (r : R) :
decompose_aux f (finsupp.single m r) =
direct_sum.of (λ i : ι, grade_by R f i) (f m)
⟨finsupp.single m r, single_mem_grade_by _ _ _⟩ | begin
refine (lift_single _ _ _).trans _,
refine (direct_sum.of_smul _ _ _ _).symm.trans _,
apply direct_sum.of_eq_of_graded_monoid_eq,
refine sigma.subtype_ext rfl _,
refine (finsupp.smul_single' _ _ _).trans _,
rw mul_one,
refl,
end | lemma | add_monoid_algebra.decompose_aux_single | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"direct_sum.of",
"direct_sum.of_eq_of_graded_monoid_eq",
"direct_sum.of_smul",
"finsupp.single",
"finsupp.smul_single'",
"mul_one",
"sigma.subtype_ext"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
decompose_aux_coe {i : ι} (x : grade_by R f i) :
decompose_aux f ↑x = direct_sum.of (λ i, grade_by R f i) i x | begin
obtain ⟨x, hx⟩ := x,
revert hx,
refine finsupp.induction x _ _,
{ intros hx,
symmetry,
exact add_monoid_hom.map_zero _ },
{ intros m b y hmy hb ih hmby,
have : disjoint (finsupp.single m b).support y.support,
{ simpa only [finsupp.support_single_ne_zero _ hb, finset.disjoint_singleton_le... | lemma | add_monoid_algebra.decompose_aux_coe | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"alg_hom.map_add",
"direct_sum.of",
"direct_sum.of_eq_of_graded_monoid_eq",
"disjoint",
"finset.coe_singleton",
"finset.coe_union",
"finset.disjoint_singleton_left",
"finsupp.induction",
"finsupp.single",
"finsupp.support_add_eq",
"finsupp.support_single_ne_zero",
"ih",
"set.singleton_subset... | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
grade_by.graded_algebra : graded_algebra (grade_by R f) | graded_algebra.of_alg_hom _
(decompose_aux f)
(begin
ext : 2,
simp only [alg_hom.coe_to_monoid_hom, function.comp_app, alg_hom.coe_comp,
function.comp.left_id, alg_hom.coe_id, add_monoid_algebra.of_apply, monoid_hom.coe_comp],
rw [decompose_aux_single, direct_sum.coe_alg_hom_of, subtype.coe_mk],... | instance | add_monoid_algebra.grade_by.graded_algebra | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"add_monoid_algebra.of_apply",
"alg_hom.coe_comp",
"alg_hom.coe_id",
"alg_hom.coe_to_monoid_hom",
"direct_sum.coe_alg_hom_of",
"graded_algebra",
"graded_algebra.of_alg_hom",
"monoid_hom.coe_comp",
"subtype.coe_mk"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
grade_by.decomposition : direct_sum.decomposition (grade_by R f) | by apply_instance | instance | add_monoid_algebra.grade_by.decomposition | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"direct_sum.decomposition"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
decompose_aux_eq_decompose :
⇑(decompose_aux f : add_monoid_algebra R M →ₐ[R] ⨁ i : ι, grade_by R f i) =
(direct_sum.decompose (grade_by R f)) | rfl | lemma | add_monoid_algebra.decompose_aux_eq_decompose | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"add_monoid_algebra",
"direct_sum.decompose"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
grades_by.decompose_single (m : M) (r : R) :
direct_sum.decompose (grade_by R f) (finsupp.single m r : add_monoid_algebra R M) =
direct_sum.of (λ i : ι, grade_by R f i) (f m)
⟨finsupp.single m r, single_mem_grade_by _ _ _⟩ | decompose_aux_single _ _ _ | lemma | add_monoid_algebra.grades_by.decompose_single | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"add_monoid_algebra",
"direct_sum.decompose",
"direct_sum.of",
"finsupp.single"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
grade.graded_algebra : graded_algebra (grade R : ι → submodule _ _) | add_monoid_algebra.grade_by.graded_algebra (add_monoid_hom.id _) | instance | add_monoid_algebra.grade.graded_algebra | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"add_monoid_algebra.grade_by.graded_algebra",
"grade",
"graded_algebra",
"submodule"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
grade.decomposition : direct_sum.decomposition (grade R : ι → submodule _ _) | by apply_instance | instance | add_monoid_algebra.grade.decomposition | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"direct_sum.decomposition",
"grade",
"submodule"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
grade.decompose_single (i : ι) (r : R) :
direct_sum.decompose (grade R : ι → submodule _ _) (finsupp.single i r : add_monoid_algebra _ _) =
direct_sum.of (λ i : ι, grade R i) i ⟨finsupp.single i r, single_mem_grade _ _⟩ | decompose_aux_single _ _ _ | lemma | add_monoid_algebra.grade.decompose_single | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"add_monoid_algebra",
"direct_sum.decompose",
"direct_sum.of",
"finsupp.single",
"grade",
"submodule"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
grade_by.is_internal : direct_sum.is_internal (grade_by R f) | direct_sum.decomposition.is_internal _ | lemma | add_monoid_algebra.grade_by.is_internal | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"direct_sum.decomposition.is_internal",
"direct_sum.is_internal"
] | `add_monoid_algebra.gradesby` describe an internally graded algebra | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
grade.is_internal : direct_sum.is_internal (grade R : ι → submodule R _) | direct_sum.decomposition.is_internal _ | lemma | add_monoid_algebra.grade.is_internal | algebra.monoid_algebra | src/algebra/monoid_algebra/grading.lean | [
"linear_algebra.finsupp",
"algebra.monoid_algebra.support",
"algebra.direct_sum.internal",
"ring_theory.graded_algebra.basic"
] | [
"direct_sum.decomposition.is_internal",
"direct_sum.is_internal",
"grade",
"submodule"
] | `add_monoid_algebra.grades` describe an internally graded algebra | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
monoid_algebra.mem_ideal_span_of_image
[monoid G] [semiring k] {s : set G} {x : monoid_algebra k G} :
x ∈ ideal.span (monoid_algebra.of k G '' s) ↔ ∀ m ∈ x.support, ∃ m' ∈ s, ∃ d, m = d * m' | begin
let RHS : ideal (monoid_algebra k G) :=
{ carrier := {p | ∀ (m : G), m ∈ p.support → ∃ m' ∈ s, ∃ d, m = d * m'},
add_mem' := λ x y hx hy m hm, by classical;
exact (finset.mem_union.1 $ finsupp.support_add hm).elim (hx m) (hy m),
zero_mem' := λ m hm, by cases hm,
smul_mem' := λ x y hy m hm, b... | lemma | monoid_algebra.mem_ideal_span_of_image | algebra.monoid_algebra | src/algebra/monoid_algebra/ideal.lean | [
"algebra.monoid_algebra.division",
"ring_theory.ideal.basic"
] | [
"Exists.imp",
"finsupp.single",
"finsupp.support_add",
"finsupp.support_single_subset",
"finsupp.support_sum",
"ideal",
"ideal.mul_mem_left",
"ideal.span",
"ideal.subset_span",
"ideal.sum_mem",
"monoid",
"monoid_algebra",
"monoid_algebra.of",
"monoid_algebra.single_mul_single",
"mul_asso... | If `x` belongs to the ideal generated by generators in `s`, then every element of the support of
`x` factors through an element of `s`.
We could spell `∃ d, m = d * m` as `mul_opposite.op m' ∣ mul_opposite.op m` but this would be worse. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
add_monoid_algebra.mem_ideal_span_of'_image
[add_monoid A] [semiring k] {s : set A} {x : add_monoid_algebra k A} :
x ∈ ideal.span (add_monoid_algebra.of' k A '' s) ↔ ∀ m ∈ x.support, ∃ m' ∈ s, ∃ d, m = d + m' | @monoid_algebra.mem_ideal_span_of_image k (multiplicative A) _ _ _ _ | lemma | add_monoid_algebra.mem_ideal_span_of'_image | algebra.monoid_algebra | src/algebra/monoid_algebra/ideal.lean | [
"algebra.monoid_algebra.division",
"ring_theory.ideal.basic"
] | [
"add_monoid",
"add_monoid_algebra",
"add_monoid_algebra.of'",
"ideal.span",
"monoid_algebra.mem_ideal_span_of_image",
"multiplicative",
"semiring"
] | If `x` belongs to the ideal generated by generators in `s`, then every element of the support of
`x` factors additively through an element of `s`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mul_apply_add_eq_mul_of_forall_ne [has_add A] {f g : add_monoid_algebra R A} {a0 b0 : A}
(h : ∀ {a b : A}, a ∈ f.support → b ∈ g.support → (a ≠ a0 ∨ b ≠ b0) → a + b ≠ a0 + b0) :
(f * g) (a0 + b0) = f a0 * g b0 | begin
classical,
rw mul_apply,
refine (finset.sum_eq_single a0 _ _).trans _,
{ exact λ b H hb, finset.sum_eq_zero (λ x H1, if_neg (h H H1 (or.inl hb))) },
{ exact λ af0, by simp [not_mem_support_iff.mp af0] },
{ refine (finset.sum_eq_single b0 (λ b bg b0, _) _).trans (if_pos rfl),
{ by_cases af : a0 ∈ f... | lemma | add_monoid_algebra.mul_apply_add_eq_mul_of_forall_ne | algebra.monoid_algebra | src/algebra/monoid_algebra/no_zero_divisors.lean | [
"algebra.monoid_algebra.support"
] | [
"add_monoid_algebra",
"zero_mul"
] | The coefficient of a monomial in a product `f * g` that can be reached in at most one way
as a product of monomials in the supports of `f` and `g` is a product. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
left.exists_add_of_mem_support_single_mul [add_left_cancel_semigroup A]
{g : add_monoid_algebra R A} (a x : A)
(hx : x ∈ (single a 1 * g : add_monoid_algebra R A).support) :
∃ b ∈ g.support, a + b = x | by rwa [support_single_mul _ _ (λ y, by rw one_mul : ∀ y : R, 1 * y = 0 ↔ _), finset.mem_map] at hx | lemma | add_monoid_algebra.left.exists_add_of_mem_support_single_mul | algebra.monoid_algebra | src/algebra/monoid_algebra/no_zero_divisors.lean | [
"algebra.monoid_algebra.support"
] | [
"add_left_cancel_semigroup",
"add_monoid_algebra",
"finset.mem_map",
"one_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
right.exists_add_of_mem_support_single_mul [add_right_cancel_semigroup A]
{f : add_monoid_algebra R A} (b x : A)
(hx : x ∈ (f * single b 1 : add_monoid_algebra R A).support) :
∃ a ∈ f.support, a + b = x | by rwa [support_mul_single _ _ (λ y, by rw mul_one : ∀ y : R, y * 1 = 0 ↔ _), finset.mem_map] at hx | lemma | add_monoid_algebra.right.exists_add_of_mem_support_single_mul | algebra.monoid_algebra | src/algebra/monoid_algebra/no_zero_divisors.lean | [
"algebra.monoid_algebra.support"
] | [
"add_monoid_algebra",
"add_right_cancel_semigroup",
"finset.mem_map",
"mul_one"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
no_zero_divisors.of_left_ordered [no_zero_divisors R]
[add_right_cancel_semigroup A] [linear_order A] [covariant_class A A (+) (<)] :
no_zero_divisors (add_monoid_algebra R A) | ⟨λ f g fg, begin
contrapose! fg,
let gmin : A := g.support.min' (support_nonempty_iff.mpr fg.2),
refine support_nonempty_iff.mp _,
obtain ⟨a, ha, H⟩ := right.exists_add_of_mem_support_single_mul gmin
((f * single gmin 1 : add_monoid_algebra R A).support.min'
(by rw support_mul_single; simp [support_no... | lemma | add_monoid_algebra.no_zero_divisors.of_left_ordered | algebra.monoid_algebra | src/algebra/monoid_algebra/no_zero_divisors.lean | [
"algebra.monoid_algebra.support"
] | [
"add_monoid_algebra",
"add_right_cancel_semigroup",
"covariant_class",
"exists_eq_right",
"exists_prop",
"finset.mem_erase_of_ne_of_mem",
"finset.mem_map",
"finset.min'_le",
"finset.min'_lt_of_mem_erase_min'",
"finset.min'_mem",
"mul_ne_zero",
"mul_one",
"no_zero_divisors"
] | If `R` is a semiring with no non-trivial zero-divisors and `A` is a left-ordered add right
cancel semigroup, then `add_monoid_algebra R A` also contains no non-zero zero-divisors. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
no_zero_divisors.of_right_ordered [no_zero_divisors R]
[add_left_cancel_semigroup A] [linear_order A] [covariant_class A A (function.swap (+)) (<)] :
no_zero_divisors (add_monoid_algebra R A) | ⟨λ f g fg, begin
contrapose! fg,
let fmin : A := f.support.min' (support_nonempty_iff.mpr fg.1),
refine support_nonempty_iff.mp _,
obtain ⟨a, ha, H⟩ := left.exists_add_of_mem_support_single_mul fmin
((single fmin 1 * g : add_monoid_algebra R A).support.min'
(by rw support_single_mul; simp [support_non... | lemma | add_monoid_algebra.no_zero_divisors.of_right_ordered | algebra.monoid_algebra | src/algebra/monoid_algebra/no_zero_divisors.lean | [
"algebra.monoid_algebra.support"
] | [
"add_left_cancel_semigroup",
"add_monoid_algebra",
"covariant_class",
"exists_eq_right",
"exists_prop",
"finset.mem_erase_of_ne_of_mem",
"finset.mem_map",
"finset.min'_le",
"finset.min'_lt_of_mem_erase_min'",
"finset.min'_mem",
"mul_ne_zero",
"no_zero_divisors",
"one_mul"
] | If `R` is a semiring with no non-trivial zero-divisors and `A` is a right-ordered add left
cancel semigroup, then `add_monoid_algebra R A` also contains no non-zero zero-divisors. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
support_single_mul_subset [decidable_eq G] [has_mul G]
(f : monoid_algebra k G) (r : k) (a : G) :
(single a r * f : monoid_algebra k G).support ⊆ finset.image ((*) a) f.support | begin
intros x hx,
contrapose hx,
have : ∀ y, a * y = x → f y = 0,
{ simpa only [not_and', mem_image, mem_support_iff, exists_prop, not_exists, not_not] using hx },
simp only [mem_support_iff, mul_apply, sum_single_index, zero_mul, if_t_t, sum_zero, not_not],
exact finset.sum_eq_zero (by simp only [this, me... | lemma | monoid_algebra.support_single_mul_subset | algebra.monoid_algebra | src/algebra/monoid_algebra/support.lean | [
"algebra.monoid_algebra.basic"
] | [
"exists_prop",
"finset.image",
"ite_eq_right_iff",
"monoid_algebra",
"mul_zero",
"not_and'",
"not_exists",
"not_not",
"zero_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
support_mul_single_subset [decidable_eq G] [has_mul G]
(f : monoid_algebra k G) (r : k) (a : G) :
(f * single a r).support ⊆ finset.image (* a) f.support | begin
intros x hx,
contrapose hx,
have : ∀ y, y * a = x → f y = 0,
{ simpa only [not_and', mem_image, mem_support_iff, exists_prop, not_exists, not_not] using hx },
simp only [mem_support_iff, mul_apply, sum_single_index, zero_mul, if_t_t, sum_zero, not_not],
exact finset.sum_eq_zero (by simp only [this, su... | lemma | monoid_algebra.support_mul_single_subset | algebra.monoid_algebra | src/algebra/monoid_algebra/support.lean | [
"algebra.monoid_algebra.basic"
] | [
"exists_prop",
"finset.image",
"ite_eq_right_iff",
"monoid_algebra",
"not_and'",
"not_exists",
"not_not",
"zero_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
support_single_mul_eq_image [decidable_eq G] [has_mul G]
(f : monoid_algebra k G) {r : k} (hr : ∀ y, r * y = 0 ↔ y = 0) {x : G} (lx : is_left_regular x) :
(single x r * f : monoid_algebra k G).support = finset.image ((*) x) f.support | begin
refine subset_antisymm (support_single_mul_subset f _ _) (λ y hy, _),
obtain ⟨y, yf, rfl⟩ : ∃ (a : G), a ∈ f.support ∧ x * a = y,
{ simpa only [finset.mem_image, exists_prop] using hy },
simp only [mul_apply, mem_support_iff.mp yf, hr, mem_support_iff, sum_single_index,
finsupp.sum_ite_eq', ne.def, no... | lemma | monoid_algebra.support_single_mul_eq_image | algebra.monoid_algebra | src/algebra/monoid_algebra/support.lean | [
"algebra.monoid_algebra.basic"
] | [
"exists_prop",
"finset.image",
"finset.mem_image",
"is_left_regular",
"monoid_algebra",
"subset_antisymm",
"zero_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
support_mul_single_eq_image [decidable_eq G] [has_mul G]
(f : monoid_algebra k G) {r : k} (hr : ∀ y, y * r = 0 ↔ y = 0) {x : G} (rx : is_right_regular x) :
(f * single x r).support = finset.image (* x) f.support | begin
refine subset_antisymm (support_mul_single_subset f _ _) (λ y hy, _),
obtain ⟨y, yf, rfl⟩ : ∃ (a : G), a ∈ f.support ∧ a * x = y,
{ simpa only [finset.mem_image, exists_prop] using hy },
simp only [mul_apply, mem_support_iff.mp yf, hr, mem_support_iff, sum_single_index,
finsupp.sum_ite_eq', ne.def, no... | lemma | monoid_algebra.support_mul_single_eq_image | algebra.monoid_algebra | src/algebra/monoid_algebra/support.lean | [
"algebra.monoid_algebra.basic"
] | [
"exists_prop",
"finset.image",
"finset.mem_image",
"is_right_regular",
"monoid_algebra",
"mul_zero",
"subset_antisymm"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
support_mul [has_mul G] [decidable_eq G] (a b : monoid_algebra k G) :
(a * b).support ⊆ a.support.bUnion (λa₁, b.support.bUnion $ λa₂, {a₁ * a₂}) | subset.trans support_sum $ bUnion_mono $ assume a₁ _,
subset.trans support_sum $ bUnion_mono $ assume a₂ _, support_single_subset | lemma | monoid_algebra.support_mul | algebra.monoid_algebra | src/algebra/monoid_algebra/support.lean | [
"algebra.monoid_algebra.basic"
] | [
"monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
support_mul_single [right_cancel_semigroup G]
(f : monoid_algebra k G) (r : k) (hr : ∀ y, y * r = 0 ↔ y = 0) (x : G) :
(f * single x r).support = f.support.map (mul_right_embedding x) | begin
classical,
ext,
simp only [support_mul_single_eq_image f hr (is_right_regular_of_right_cancel_semigroup x),
mem_image, mem_map, mul_right_embedding_apply],
end | lemma | monoid_algebra.support_mul_single | algebra.monoid_algebra | src/algebra/monoid_algebra/support.lean | [
"algebra.monoid_algebra.basic"
] | [
"is_right_regular_of_right_cancel_semigroup",
"mem_map",
"monoid_algebra",
"mul_right_embedding",
"right_cancel_semigroup"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
support_single_mul [left_cancel_semigroup G]
(f : monoid_algebra k G) (r : k) (hr : ∀ y, r * y = 0 ↔ y = 0) (x : G) :
(single x r * f : monoid_algebra k G).support = f.support.map (mul_left_embedding x) | begin
classical,
ext,
simp only [support_single_mul_eq_image f hr (is_left_regular_of_left_cancel_semigroup x),
mem_image, mem_map, mul_left_embedding_apply],
end | lemma | monoid_algebra.support_single_mul | algebra.monoid_algebra | src/algebra/monoid_algebra/support.lean | [
"algebra.monoid_algebra.basic"
] | [
"is_left_regular_of_left_cancel_semigroup",
"left_cancel_semigroup",
"mem_map",
"monoid_algebra",
"mul_left_embedding"
] | 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.