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 |
|---|---|---|---|---|---|---|---|---|---|---|
single_pow [monoid G] {a : G} {b : k} :
∀ n : ℕ, (single a b : monoid_algebra k G)^n = single (a^n) (b ^ n) | | 0 := by { simp only [pow_zero], refl }
| (n+1) := by simp only [pow_succ, single_pow n, single_mul_single] | lemma | monoid_algebra.single_pow | 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"
] | [
"monoid",
"monoid_algebra",
"pow_succ",
"pow_zero"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_domain_one {α : Type*} {β : Type*} {α₂ : Type*}
[semiring β] [has_one α] [has_one α₂] {F : Type*} [one_hom_class F α α₂] (f : F) :
(map_domain f (1 : monoid_algebra β α) : monoid_algebra β α₂) = (1 : monoid_algebra β α₂) | by simp_rw [one_def, map_domain_single, map_one] | lemma | monoid_algebra.map_domain_one | 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"
] | [
"map_one",
"monoid_algebra",
"one_hom_class",
"semiring"
] | Like `finsupp.map_domain_zero`, but for the `1` we define in this file | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
map_domain_mul {α : Type*} {β : Type*} {α₂ : Type*} [semiring β] [has_mul α] [has_mul α₂]
{F : Type*} [mul_hom_class F α α₂] (f : F) (x y : monoid_algebra β α) :
(map_domain f (x * y : monoid_algebra β α) : monoid_algebra β α₂) =
(map_domain f x * map_domain f y : monoid_algebra β α₂) | begin
simp_rw [mul_def, map_domain_sum, map_domain_single, map_mul],
rw finsupp.sum_map_domain_index,
{ congr,
ext a b,
rw finsupp.sum_map_domain_index,
{ simp },
{ simp [mul_add] } },
{ simp },
{ simp [add_mul] }
end | lemma | monoid_algebra.map_domain_mul | 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"
] | [
"map_mul",
"monoid_algebra",
"mul_hom_class",
"semiring"
] | Like `finsupp.map_domain_add`, but for the convolutive multiplication we define in this file | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
of_magma [has_mul G] : G →ₙ* (monoid_algebra k G) | { to_fun := λ a, single a 1,
map_mul' := λ a b, by simp only [mul_def, mul_one, sum_single_index, single_eq_zero, mul_zero], } | def | monoid_algebra.of_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"
] | [
"monoid_algebra",
"mul_one",
"mul_zero"
] | The embedding of a magma into its magma algebra. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
of [mul_one_class G] : G →* monoid_algebra k G | { to_fun := λ a, single a 1,
map_one' := rfl,
.. of_magma k G } | def | monoid_algebra.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"
] | [
"monoid_algebra",
"mul_one_class"
] | The embedding of a unital magma into its magma algebra. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
smul_of [mul_one_class G] (g : G) (r : k) :
r • (of k G g) = single g r | by simp | lemma | monoid_algebra.smul_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"
] | [
"mul_one_class"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of_injective [mul_one_class G] [nontrivial k] : function.injective (of k G) | λ a b h, by simpa using (single_eq_single_iff _ _ _ _).mp h | lemma | monoid_algebra.of_injective | 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"
] | [
"mul_one_class",
"nontrivial"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_hom [mul_one_class G] : k × G →* monoid_algebra k G | { to_fun := λ a, single a.2 a.1,
map_one' := rfl,
map_mul' := λ a b, single_mul_single.symm } | def | monoid_algebra.single_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"
] | [
"monoid_algebra",
"mul_one_class"
] | `finsupp.single` as a `monoid_hom` from the product type into the monoid algebra.
Note the order of the elements of the product are reversed compared to the arguments of
`finsupp.single`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mul_single_apply_aux [has_mul G] (f : monoid_algebra k G) {r : k}
{x y z : G} (H : ∀ a, a * x = z ↔ a = y) :
(f * single x r) z = f y * r | by classical; exact
have A : ∀ a₁ b₁, (single x r).sum (λ a₂ b₂, ite (a₁ * a₂ = z) (b₁ * b₂) 0) =
ite (a₁ * x = z) (b₁ * r) 0,
from λ a₁ b₁, sum_single_index $ by simp,
calc (f * single x r) z = sum f (λ a b, if (a = y) then (b * r) else 0) :
by simp only [mul_apply, A, H]
... = if y ∈ f.support then f y * r else 0... | lemma | monoid_algebra.mul_single_apply_aux | 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"
] | [
"monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_single_one_apply [mul_one_class G] (f : monoid_algebra k G) (r : k) (x : G) :
(f * single 1 r) x = f x * r | f.mul_single_apply_aux $ λ a, by rw [mul_one] | lemma | monoid_algebra.mul_single_one_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"
] | [
"monoid_algebra",
"mul_one",
"mul_one_class"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_single_apply_of_not_exists_mul [has_mul G] (r : k) {g g' : G} (x : monoid_algebra k G)
(h : ¬∃ d, g' = d * g):
(x * finsupp.single g r : monoid_algebra k G) g' = 0 | begin
classical,
rw [mul_apply, finsupp.sum_comm, finsupp.sum_single_index],
swap,
{ simp_rw [finsupp.sum, mul_zero, if_t_t, finset.sum_const_zero] },
{ apply finset.sum_eq_zero,
simp_rw ite_eq_right_iff,
rintros g'' hg'' rfl,
exfalso,
exact h ⟨_, rfl⟩ }
end | lemma | monoid_algebra.mul_single_apply_of_not_exists_mul | 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"
] | [
"finsupp.single",
"ite_eq_right_iff",
"monoid_algebra",
"mul_zero"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_mul_apply_aux [has_mul G] (f : monoid_algebra k G) {r : k} {x y z : G}
(H : ∀ a, x * a = y ↔ a = z) :
(single x r * f) y = r * f z | by classical; exact (
have f.sum (λ a b, ite (x * a = y) (0 * b) 0) = 0, by simp,
calc (single x r * f) y = sum f (λ a b, ite (x * a = y) (r * b) 0) :
(mul_apply _ _ _).trans $ sum_single_index (by exact this)
... = f.sum (λ a b, ite (a = z) (r * b) 0) : by simp only [H]
... = if z ∈ f.support then (r * f z) else 0 :... | lemma | monoid_algebra.single_mul_apply_aux | 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"
] | [
"monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_one_mul_apply [mul_one_class G] (f : monoid_algebra k G) (r : k) (x : G) :
(single 1 r * f) x = r * f x | f.single_mul_apply_aux $ λ a, by rw [one_mul] | lemma | monoid_algebra.single_one_mul_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"
] | [
"monoid_algebra",
"mul_one_class",
"one_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_mul_apply_of_not_exists_mul [has_mul G] (r : k) {g g' : G} (x : monoid_algebra k G)
(h : ¬∃ d, g' = g * d):
(finsupp.single g r * x : monoid_algebra k G) g' = 0 | begin
classical,
rw [mul_apply, finsupp.sum_single_index],
swap,
{ simp_rw [finsupp.sum, zero_mul, if_t_t, finset.sum_const_zero] },
{ apply finset.sum_eq_zero,
simp_rw ite_eq_right_iff,
rintros g'' hg'' rfl,
exfalso,
exact h ⟨_, rfl⟩ },
end | lemma | monoid_algebra.single_mul_apply_of_not_exists_mul | 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"
] | [
"finsupp.single",
"ite_eq_right_iff",
"monoid_algebra",
"zero_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_nc_smul [mul_one_class G] {R : Type*} [semiring R] (f : k →+* R) (g : G →* R) (c : k)
(φ : monoid_algebra k G) :
lift_nc (f : k →+ R) g (c • φ) = f c * lift_nc (f : k →+ R) g φ | begin
suffices : (lift_nc ↑f g).comp (smul_add_hom k (monoid_algebra k G) c) =
(add_monoid_hom.mul_left (f c)).comp (lift_nc ↑f g),
from add_monoid_hom.congr_fun this φ,
ext a b, simp [mul_assoc]
end | lemma | monoid_algebra.lift_nc_smul | 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_hom.mul_left",
"monoid_algebra",
"mul_assoc",
"mul_one_class",
"semiring",
"smul_add_hom"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_scalar_tower_self [is_scalar_tower R k k] :
is_scalar_tower R (monoid_algebra k G) (monoid_algebra k G) | ⟨λ t a b,
begin
ext m,
classical,
simp only [mul_apply, finsupp.smul_sum, smul_ite, smul_mul_assoc, sum_smul_index', zero_mul,
if_t_t, implies_true_iff, eq_self_iff_true, sum_zero, coe_smul, smul_eq_mul, pi.smul_apply,
smul_zero],
end⟩ | instance | monoid_algebra.is_scalar_tower_self | 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"
] | [
"finsupp.smul_sum",
"is_scalar_tower",
"monoid_algebra",
"pi.smul_apply",
"smul_eq_mul",
"smul_ite",
"smul_mul_assoc",
"smul_zero",
"zero_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
smul_comm_class_self [smul_comm_class R k k] :
smul_comm_class R (monoid_algebra k G) (monoid_algebra k G) | ⟨λ t a b, begin
classical,
ext m,
simp only [mul_apply, finsupp.sum, finset.smul_sum, smul_ite, mul_smul_comm, sum_smul_index',
implies_true_iff, eq_self_iff_true, coe_smul, ite_eq_right_iff, smul_eq_mul, pi.smul_apply,
mul_zero, smul_zero],
end⟩ | instance | monoid_algebra.smul_comm_class_self | 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"
] | [
"finset.smul_sum",
"ite_eq_right_iff",
"monoid_algebra",
"mul_smul_comm",
"mul_zero",
"pi.smul_apply",
"smul_comm_class",
"smul_comm_class_self",
"smul_eq_mul",
"smul_ite",
"smul_zero"
] | Note that if `k` is a `comm_semiring` then we have `smul_comm_class k k k` and so we can take
`R = k` in the below. In other words, if the coefficients are commutative amongst themselves, they
also commute with the algebra multiplication. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
smul_comm_class_symm_self [smul_comm_class k R k] :
smul_comm_class (monoid_algebra k G) R (monoid_algebra k G) | ⟨λ t a b, by { haveI := smul_comm_class.symm k R k, rw ← smul_comm, } ⟩ | instance | monoid_algebra.smul_comm_class_symm_self | 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"
] | [
"monoid_algebra",
"smul_comm_class",
"smul_comm_class.symm"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
non_unital_alg_hom_ext [distrib_mul_action k A]
{φ₁ φ₂ : monoid_algebra k G →ₙₐ[k] A}
(h : ∀ x, φ₁ (single x 1) = φ₂ (single x 1)) : φ₁ = φ₂ | non_unital_alg_hom.to_distrib_mul_action_hom_injective $
finsupp.distrib_mul_action_hom_ext' $
λ a, distrib_mul_action_hom.ext_ring (h a) | lemma | 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"
] | [
"distrib_mul_action",
"distrib_mul_action_hom.ext_ring",
"finsupp.distrib_mul_action_hom_ext'",
"monoid_algebra",
"non_unital_alg_hom.to_distrib_mul_action_hom_injective"
] | A non_unital `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 |
non_unital_alg_hom_ext' [distrib_mul_action k A]
{φ₁ φ₂ : monoid_algebra k G →ₙₐ[k] A}
(h : φ₁.to_mul_hom.comp (of_magma k G) = φ₂.to_mul_hom.comp (of_magma k G)) : φ₁ = φ₂ | non_unital_alg_hom_ext k $ mul_hom.congr_fun h | lemma | 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"
] | [
"distrib_mul_action",
"monoid_algebra",
"mul_hom.congr_fun"
] | 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] :
(G →ₙ* A) ≃ (monoid_algebra k G →ₙₐ[k] A) | { to_fun := λ f,
{ to_fun := λ a, a.sum (λ m t, t • f m),
map_smul' := λ t' a,
begin
rw [finsupp.smul_sum, sum_smul_index'],
{ simp_rw smul_assoc, },
{ intros m, exact zero_smul k (f m), },
end,
map_mul' := λ a₁ a₂,
begin
let g : G ... | def | 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_smul",
"finsupp.mul_sum",
"finsupp.smul_sum",
"finsupp.sum_mul",
"inv_fun",
"is_scalar_tower",
"module",
"monoid_algebra",
"mul_hom.coe_comp",
"non_unital_alg_hom.coe_mk",
"non_unital_alg_hom.coe_to_mul_hom",
"non_unital_alg_hom.to_mul_hom_eq_coe",
"one_smul",
"smul_add_hom",
"smul_... | The functor `G ↦ 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_one_comm [comm_semiring k] [mul_one_class G] (r : k) (f : monoid_algebra k G) :
single 1 r * f = f * single 1 r | by { ext, rw [single_one_mul_apply, mul_single_one_apply, mul_comm] } | lemma | monoid_algebra.single_one_comm | 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"
] | [
"comm_semiring",
"monoid_algebra",
"mul_comm",
"mul_one_class"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_one_ring_hom [semiring k] [mul_one_class G] : k →+* monoid_algebra k G | { map_one' := rfl,
map_mul' := λ x y, by rw [single_add_hom, single_mul_single, one_mul],
..finsupp.single_add_hom 1} | def | monoid_algebra.single_one_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"
] | [
"finsupp.single_add_hom",
"monoid_algebra",
"mul_one_class",
"one_mul",
"semiring"
] | `finsupp.single 1` as a `ring_hom` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
map_domain_ring_hom (k : Type*) {H F : Type*} [semiring k] [monoid G] [monoid H]
[monoid_hom_class F G H] (f : F) :
monoid_algebra k G →+* monoid_algebra k H | { map_one' := map_domain_one f,
map_mul' := λ x y, map_domain_mul f x y,
..(finsupp.map_domain.add_monoid_hom f : monoid_algebra k G →+ monoid_algebra k H) } | def | monoid_algebra.map_domain_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"
] | [
"finsupp.map_domain.add_monoid_hom",
"monoid",
"monoid_algebra",
"monoid_hom_class",
"semiring"
] | If `f : G → H` is a multiplicative homomorphism between two monoids, then
`finsupp.map_domain f` is a ring homomorphism between their monoid algebras. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
ring_hom_ext {R} [semiring k] [mul_one_class G] [semiring R]
{f g : monoid_algebra k G →+* R} (h₁ : ∀ b, f (single 1 b) = g (single 1 b))
(h_of : ∀ a, f (single a 1) = g (single a 1)) : f = g | ring_hom.coe_add_monoid_hom_injective $ add_hom_ext $ λ a b,
by rw [← one_mul a, ← mul_one b, ← single_mul_single, f.coe_add_monoid_hom,
g.coe_add_monoid_hom, f.map_mul, g.map_mul, h₁, h_of] | lemma | 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"
] | [
"monoid_algebra",
"mul_one",
"mul_one_class",
"one_mul",
"ring_hom.coe_add_monoid_hom_injective",
"ring_hom_ext",
"semiring"
] | If two ring homomorphisms from `monoid_algebra k G` are equal on all `single a 1`
and `single 1 b`, then they are equal. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
ring_hom_ext' {R} [semiring k] [mul_one_class G] [semiring R]
{f g : monoid_algebra k G →+* R} (h₁ : f.comp single_one_ring_hom = g.comp single_one_ring_hom)
(h_of : (f : monoid_algebra k G →* R).comp (of k G) =
(g : 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 | 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"
] | [
"monoid_algebra",
"monoid_hom.congr_fun",
"mul_one_class",
"ring_hom.congr_fun",
"ring_hom_ext",
"semiring"
] | If two ring homomorphisms from `monoid_algebra k G` are equal on all `single a 1`
and `single 1 b`, then they are equal.
See note [partially-applied ext lemmas]. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
single_one_alg_hom {A : Type*} [comm_semiring k] [semiring A] [algebra k A] [monoid G] :
A →ₐ[k] monoid_algebra A G | { commutes' := λ r, by { ext, simp, refl, }, ..single_one_ring_hom} | def | monoid_algebra.single_one_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"
] | [
"algebra",
"comm_semiring",
"monoid",
"monoid_algebra",
"semiring"
] | `finsupp.single 1` as a `alg_hom` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
coe_algebra_map {A : Type*} [comm_semiring k] [semiring A] [algebra k A] [monoid G] :
⇑(algebra_map k (monoid_algebra A G)) = single 1 ∘ (algebra_map k A) | rfl | lemma | 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"
] | [
"algebra",
"algebra_map",
"comm_semiring",
"monoid",
"monoid_algebra",
"semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_eq_algebra_map_mul_of [comm_semiring k] [monoid G] (a : G) (b : k) :
single a b = algebra_map k (monoid_algebra k G) b * of k G a | by simp | lemma | monoid_algebra.single_eq_algebra_map_mul_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"
] | [
"algebra_map",
"comm_semiring",
"monoid",
"monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_algebra_map_eq_algebra_map_mul_of {A : Type*} [comm_semiring k] [semiring A]
[algebra k A] [monoid G] (a : G) (b : k) :
single a (algebra_map k A b) = algebra_map k (monoid_algebra A G) b * of A G a | by simp | lemma | monoid_algebra.single_algebra_map_eq_algebra_map_mul_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"
] | [
"algebra",
"algebra_map",
"comm_semiring",
"monoid",
"monoid_algebra",
"semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
induction_on [semiring k] [monoid G] {p : monoid_algebra k G → Prop} (f : monoid_algebra k G)
(hM : ∀ g, p (of k G g)) (hadd : ∀ f g : monoid_algebra k G, p f → p g → p (f + g))
(hsmul : ∀ (r : k) f, p f → p (r • f)) : p f | begin
refine finsupp.induction_linear f _ (λ f g hf hg, hadd f g hf hg) (λ g r, _),
{ simpa using hsmul 0 (of k G 1) (hM 1) },
{ convert hsmul r (of k G g) (hM g),
simp only [mul_one, smul_single', of_apply] },
end | lemma | monoid_algebra.induction_on | 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"
] | [
"finsupp.induction_linear",
"monoid",
"monoid_algebra",
"mul_one",
"semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_nc_alg_hom (f : A →ₐ[k] B) (g : G →* B) (h_comm : ∀ x y, commute (f x) (g y)) :
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 | 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"
] | [
"commute",
"monoid_algebra"
] | `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 ⦃φ₁ φ₂ : monoid_algebra k G →ₐ[k] A⦄
(h : ∀ x, φ₁ (single x 1) = φ₂ (single x 1)) : φ₁ = φ₂ | alg_hom.to_linear_map_injective $ finsupp.lhom_ext' $ λ a, linear_map.ext_ring (h a) | lemma | 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"
] | [
"alg_hom.to_linear_map_injective",
"finsupp.lhom_ext'",
"linear_map.ext_ring",
"monoid_algebra"
] | 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' ⦃φ₁ φ₂ : monoid_algebra k G →ₐ[k] A⦄
(h : (φ₁ : monoid_algebra k G →* A).comp (of k G) =
(φ₂ : monoid_algebra k G →* A).comp (of k G)) : φ₁ = φ₂ | alg_hom_ext $ monoid_hom.congr_fun h | lemma | 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"
] | [
"monoid_algebra",
"monoid_hom.congr_fun"
] | See note [partially-applied ext lemmas]. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
lift : (G →* A) ≃ (monoid_algebra k G →ₐ[k] A) | { inv_fun := λ f, (f : monoid_algebra k G →* A).comp (of k G),
to_fun := λ F, lift_nc_alg_hom (algebra.of_id k A) F $ λ _ _, algebra.commutes _ _,
left_inv := λ f, by { ext, simp [lift_nc_alg_hom, lift_nc_ring_hom] },
right_inv := λ F, by { ext, simp [lift_nc_alg_hom, lift_nc_ring_hom] } } | def | 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"
] | [
"algebra.commutes",
"algebra.of_id",
"inv_fun",
"lift",
"monoid_algebra"
] | 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 : G →* A) (f : monoid_algebra k G) :
lift k G A F f = f.sum (λ a b, (algebra_map k A b) * F a) | rfl | lemma | 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"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_apply (F : G →* A) (f : monoid_algebra k G) :
lift k G A F f = f.sum (λ a b, b • F a) | by simp only [lift_apply', algebra.smul_def] | lemma | 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"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_def (F : G →* A) :
⇑(lift k G A F) = lift_nc ((algebra_map k A : k →+* A) : k →+ A) F | rfl | lemma | 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"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_symm_apply (F : monoid_algebra k G →ₐ[k] A) (x : G) :
(lift k G A).symm F x = F (single x 1) | rfl | lemma | 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"
] | [
"lift",
"monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_of (F : G →* A) (x) :
lift k G A F (of k G x) = F x | by rw [of_apply, ← lift_symm_apply, equiv.symm_apply_apply] | lemma | 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"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_single (F : G →* A) (a b) :
lift k G A F (single a b) = b • F a | by rw [lift_def, lift_nc_single, algebra.smul_def, ring_hom.coe_add_monoid_hom] | lemma | 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",
"ring_hom.coe_add_monoid_hom"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_unique' (F : monoid_algebra k G →ₐ[k] A) :
F = lift k G A ((F : monoid_algebra k G →* A).comp (of k G)) | ((lift k G A).apply_symm_apply F).symm | lemma | 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"
] | [
"lift",
"monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_unique (F : 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 | 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"
] | [
"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 |
map_domain_non_unital_alg_hom (k A : Type*) [comm_semiring k] [semiring A] [algebra k A]
{G H F : Type*} [has_mul G] [has_mul H] [mul_hom_class F G H] (f : F) :
monoid_algebra A G →ₙₐ[k] 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 | 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"
] | [
"algebra",
"comm_semiring",
"finsupp.map_domain.add_monoid_hom",
"monoid_algebra",
"mul_hom_class",
"semiring"
] | If `f : G → H` is a homomorphism between two magmas, then
`finsupp.map_domain f` is a non-unital algebra homomorphism between their magma algebras. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
map_domain_algebra_map (k A : Type*) {H F : Type*} [comm_semiring k] [semiring A]
[algebra k A] [monoid H] [monoid_hom_class F G H] (f : F) (r : k) :
map_domain f (algebra_map k (monoid_algebra A G) r) =
algebra_map k (monoid_algebra A H) r | by simp only [coe_algebra_map, map_domain_single, map_one] | lemma | 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"
] | [
"algebra",
"algebra_map",
"comm_semiring",
"map_one",
"monoid",
"monoid_algebra",
"monoid_hom_class",
"semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_domain_alg_hom (k A : Type*) [comm_semiring k] [semiring A] [algebra k A] {H F : Type*}
[monoid H] [monoid_hom_class F G H] (f : F) :
monoid_algebra A G →ₐ[k] monoid_algebra A H | { commutes' := map_domain_algebra_map k A f,
..map_domain_ring_hom A f} | def | 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"
] | [
"algebra",
"comm_semiring",
"monoid",
"monoid_algebra",
"monoid_hom_class",
"semiring"
] | If `f : G → H` is a multiplicative homomorphism between two monoids, then
`finsupp.map_domain f` is an algebra homomorphism between their monoid algebras. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
group_smul.linear_map [monoid G] [comm_semiring k]
(V : Type u₃) [add_comm_monoid V] [module k V] [module (monoid_algebra k G) V]
[is_scalar_tower k (monoid_algebra k G) V] (g : G) :
V →ₗ[k] V | { to_fun := λ v, (single g (1 : k) • v : V),
map_add' := λ x y, smul_add (single g (1 : k)) x y,
map_smul' := λ c x, smul_algebra_smul_comm _ _ _ } | def | monoid_algebra.group_smul.linear_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_comm_monoid",
"comm_semiring",
"is_scalar_tower",
"module",
"monoid",
"monoid_algebra",
"smul_add",
"smul_algebra_smul_comm"
] | When `V` is a `k[G]`-module, multiplication by a group element `g` is a `k`-linear map. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
group_smul.linear_map_apply [monoid G] [comm_semiring k]
(V : Type u₃) [add_comm_monoid V] [module k V] [module (monoid_algebra k G) V]
[is_scalar_tower k (monoid_algebra k G) V] (g : G) (v : V) :
(group_smul.linear_map k V g) v = (single g (1 : k) • v : V) | rfl | lemma | monoid_algebra.group_smul.linear_map_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_comm_monoid",
"comm_semiring",
"is_scalar_tower",
"module",
"monoid",
"monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
equivariant_of_linear_of_comm : V →ₗ[monoid_algebra k G] W | { to_fun := f,
map_add' := λ v v', by simp,
map_smul' := λ c v,
begin
apply finsupp.induction c,
{ simp, },
{ intros g r c' nm nz w,
dsimp at *,
simp only [add_smul, f.map_add, w, add_left_inj, single_eq_algebra_map_mul_of, ← smul_smul],
erw [algebra_map_smul (monoid_algebra k G) r, algebra_map_... | def | monoid_algebra.equivariant_of_linear_of_comm | 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_smul",
"algebra_map_smul",
"finsupp.induction",
"monoid_algebra",
"smul_smul"
] | Build a `k[G]`-linear map from a `k`-linear map and evidence that it is `G`-equivariant. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
equivariant_of_linear_of_comm_apply (v : V) : (equivariant_of_linear_of_comm f h) v = f v | rfl | lemma | monoid_algebra.equivariant_of_linear_of_comm_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"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_single [comm_semiring k] [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, prod_cons has, prod_cons has] | lemma | 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"
] | [
"comm_monoid",
"comm_semiring",
"finset",
"finset.cons_induction_on",
"ih"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_single_apply (f : monoid_algebra k G) (r : k) (x y : G) :
(f * single x r) y = f (y * x⁻¹) * r | f.mul_single_apply_aux $ λ a, eq_mul_inv_iff_mul_eq.symm | lemma | monoid_algebra.mul_single_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"
] | [
"monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_mul_apply (r : k) (x : G) (f : monoid_algebra k G) (y : G) :
(single x r * f) y = r * f (x⁻¹ * y) | f.single_mul_apply_aux $ λ z, eq_inv_mul_iff_mul_eq.symm | lemma | monoid_algebra.single_mul_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"
] | [
"monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_apply_left (f g : monoid_algebra k G) (x : G) :
(f * g) x = (f.sum $ λ a b, b * (g (a⁻¹ * x))) | calc (f * g) x = sum f (λ a b, (single a b * g) x) :
by rw [← finsupp.sum_apply, ← finsupp.sum_mul, f.sum_single]
... = _ : by simp only [single_mul_apply, finsupp.sum] | lemma | monoid_algebra.mul_apply_left | 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"
] | [
"finsupp.sum_apply",
"finsupp.sum_mul",
"monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_apply_right (f g : monoid_algebra k G) (x : G) :
(f * g) x = (g.sum $ λa b, (f (x * a⁻¹)) * b) | calc (f * g) x = sum g (λ a b, (f * single a b) x) :
by rw [← finsupp.sum_apply, ← finsupp.mul_sum, g.sum_single]
... = _ : by simp only [mul_single_apply, finsupp.sum] | lemma | monoid_algebra.mul_apply_right | 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"
] | [
"finsupp.mul_sum",
"finsupp.sum_apply",
"monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
op_ring_equiv [monoid G] :
(monoid_algebra k G)ᵐᵒᵖ ≃+* 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,
simp
end,
..op_add_equiv.symm.trans $ (finsupp.map_range.add_equiv (op_add_equiv : k ≃+ kᵐᵒᵖ)).trans $
finsupp.dom_congr op_equiv } | def | 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_monoid_hom.map_mul_iff",
"finsupp.dom_congr",
"finsupp.map_range.add_equiv",
"monoid",
"monoid_algebra"
] | The opposite of an `monoid_algebra R I` equivalent as a ring to
the `monoid_algebra Rᵐᵒᵖ Iᵐᵒᵖ` over the opposite ring, taking elements to their opposite. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
op_ring_equiv_single [monoid G] (r : k) (x : G) :
monoid_algebra.op_ring_equiv (op (single x r)) = single (op x) (op r) | by simp | lemma | 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"
] | [
"monoid",
"monoid_algebra.op_ring_equiv"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
op_ring_equiv_symm_single [monoid G] (r : kᵐᵒᵖ) (x : Gᵐᵒᵖ) :
monoid_algebra.op_ring_equiv.symm (single x r) = op (single x.unop r.unop) | by simp | lemma | 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"
] | [
"monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
submodule_of_smul_mem (W : submodule k V) (h : ∀ (g : G) (v : V), v ∈ W → (of k G g) • v ∈ W) :
submodule (monoid_algebra k G) V | { carrier := W,
zero_mem' := W.zero_mem',
add_mem' := λ _ _, W.add_mem',
smul_mem' := begin
intros f v hv,
rw [←finsupp.sum_single f, finsupp.sum, finset.sum_smul],
simp_rw [←smul_of, smul_assoc],
exact submodule.sum_smul_mem W _ (λ g _, h g v hv)
end } | def | monoid_algebra.submodule_of_smul_mem | 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"
] | [
"finset.sum_smul",
"monoid_algebra",
"smul_assoc",
"submodule",
"submodule.sum_smul_mem"
] | A submodule over `k` which is stable under scalar multiplication by elements of `G` is a
submodule over `monoid_algebra k G` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
add_monoid_algebra | G →₀ k | def | add_monoid_algebra | 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"
] | [] | The monoid algebra over a semiring `k` generated by the additive monoid `G`.
It is the type of finite formal `k`-linear combinations of terms of `G`,
endowed with the convolution product. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
lift_nc (f : k →+ R) (g : multiplicative G → R) : add_monoid_algebra k G →+ R | lift_add_hom (λ x : G, (add_monoid_hom.mul_right (g $ multiplicative.of_add x)).comp f) | def | add_monoid_algebra.lift_nc | 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",
"add_monoid_hom.mul_right",
"multiplicative",
"multiplicative.of_add"
] | A non-commutative version of `add_monoid_algebra.lift`: given a additive homomorphism `f : k →+
R` and a map `g : multiplicative G → R`, returns the additive
homomorphism from `add_monoid_algebra k G` such that `lift_nc f g (single a b) = f b * g a`. If `f`
is a ring homomorphism and the range of either `f` or `g` is i... | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
lift_nc_single (f : k →+ R) (g : multiplicative G → R) (a : G) (b : k) :
lift_nc f g (single a b) = f b * g (multiplicative.of_add a) | lift_add_hom_apply_single _ _ _ | lemma | add_monoid_algebra.lift_nc_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"
] | [
"multiplicative",
"multiplicative.of_add"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_def {f g : add_monoid_algebra k G} :
f * g = (f.sum $ λa₁ b₁, g.sum $ λa₂ b₂, single (a₁ + a₂) (b₁ * b₂)) | rfl | lemma | add_monoid_algebra.mul_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"
] | [
"add_monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_nc_mul {g_hom : Type*} [mul_hom_class g_hom (multiplicative G) R] (f : k →+* R)
(g : g_hom) (a b : add_monoid_algebra k G)
(h_comm : ∀ {x y}, y ∈ a.support → commute (f (b x)) (g $ multiplicative.of_add y)) :
lift_nc (f : k →+ R) g (a * b) = lift_nc (f : k →+ R) g a * lift_nc (f : k →+ R) g b | (monoid_algebra.lift_nc_mul f g _ _ @h_comm : _) | lemma | add_monoid_algebra.lift_nc_mul | 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",
"monoid_algebra.lift_nc_mul",
"mul_hom_class",
"multiplicative",
"multiplicative.of_add"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
one_def : (1 : add_monoid_algebra k G) = single 0 1 | rfl | lemma | add_monoid_algebra.one_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"
] | [
"add_monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_nc_one {g_hom : Type*} [one_hom_class g_hom (multiplicative G) R]
(f : k →+* R) (g : g_hom) :
lift_nc (f : k →+ R) g 1 = 1 | (monoid_algebra.lift_nc_one f g : _) | lemma | add_monoid_algebra.lift_nc_one | 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"
] | [
"monoid_algebra.lift_nc_one",
"multiplicative",
"one_hom_class"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
nat_cast_def (n : ℕ) : (n : add_monoid_algebra k G) = single 0 n | rfl | lemma | add_monoid_algebra.nat_cast_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"
] | [
"add_monoid_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_nc_ring_hom (f : k →+* R) (g : multiplicative G →* R)
(h_comm : ∀ x y, commute (f x) (g y)) :
add_monoid_algebra k G →+* R | { to_fun := lift_nc (f : k →+ R) g,
map_one' := lift_nc_one _ _,
map_mul' := λ a b, lift_nc_mul _ _ _ _ $ λ _ _ _, h_comm _ _,
..(lift_nc (f : k →+ R) g)} | def | add_monoid_algebra.lift_nc_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_algebra",
"commute",
"multiplicative"
] | `lift_nc` as a `ring_hom`, for when `f` and `g` commute | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
int_cast_def [ring k] [add_zero_class G] (z : ℤ) :
(z : add_monoid_algebra k G) = single 0 z | rfl | lemma | add_monoid_algebra.int_cast_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"
] | [
"add_monoid_algebra",
"add_zero_class",
"ring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_apply [decidable_eq G] [has_add G] (f g : add_monoid_algebra k G) (x : G) :
(f * g) x = (f.sum $ λa₁ b₁, g.sum $ λa₂ b₂, if a₁ + a₂ = x then b₁ * b₂ else 0) | @monoid_algebra.mul_apply k (multiplicative G) _ _ _ _ _ _ | lemma | add_monoid_algebra.mul_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",
"monoid_algebra.mul_apply",
"multiplicative"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_apply_antidiagonal [has_add G] (f g : add_monoid_algebra k G) (x : G) (s : finset (G × G))
(hs : ∀ {p : G × G}, p ∈ s ↔ p.1 + p.2 = x) :
(f * g) x = ∑ p in s, (f p.1 * g p.2) | @monoid_algebra.mul_apply_antidiagonal k (multiplicative G) _ _ _ _ _ s @hs | lemma | add_monoid_algebra.mul_apply_antidiagonal | 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",
"finset",
"monoid_algebra.mul_apply_antidiagonal",
"multiplicative"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_mul_single [has_add G] {a₁ a₂ : G} {b₁ b₂ : k} :
(single a₁ b₁ * single a₂ b₂ : add_monoid_algebra k G) = single (a₁ + a₂) (b₁ * b₂) | @monoid_algebra.single_mul_single k (multiplicative G) _ _ _ _ _ _ | lemma | add_monoid_algebra.single_mul_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_monoid_algebra",
"monoid_algebra.single_mul_single",
"multiplicative"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_pow [add_monoid G] {a : G} {b : k} :
∀ n : ℕ, ((single a b)^n : add_monoid_algebra k G) = single (n • a) (b ^ n) | | 0 := by { simp only [pow_zero, zero_nsmul], refl }
| (n+1) :=
by rw [pow_succ, pow_succ, single_pow n, single_mul_single, add_comm, add_nsmul, one_nsmul] | lemma | add_monoid_algebra.single_pow | 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",
"pow_succ",
"pow_zero"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_domain_one {α : Type*} {β : Type*} {α₂ : Type*}
[semiring β] [has_zero α] [has_zero α₂] {F : Type*} [zero_hom_class F α α₂] (f : F) :
(map_domain f (1 : add_monoid_algebra β α) : add_monoid_algebra β α₂) =
(1 : add_monoid_algebra β α₂) | by simp_rw [one_def, map_domain_single, map_zero] | lemma | add_monoid_algebra.map_domain_one | 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",
"semiring",
"zero_hom_class"
] | Like `finsupp.map_domain_zero`, but for the `1` we define in this file | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
map_domain_mul {α : Type*} {β : Type*} {α₂ : Type*} [semiring β] [has_add α] [has_add α₂]
{F : Type*} [add_hom_class F α α₂] (f : F) (x y : add_monoid_algebra β α) :
(map_domain f (x * y : add_monoid_algebra β α) : add_monoid_algebra β α₂) =
(map_domain f x * map_domain f y : add_monoid_algebra β α₂) | begin
simp_rw [mul_def, map_domain_sum, map_domain_single, map_add],
rw finsupp.sum_map_domain_index,
{ congr,
ext a b,
rw finsupp.sum_map_domain_index,
{ simp },
{ simp [mul_add] } },
{ simp },
{ simp [add_mul] }
end | lemma | add_monoid_algebra.map_domain_mul | 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",
"semiring"
] | Like `finsupp.map_domain_add`, but for the convolutive multiplication we define in this file | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
of_magma [has_add G] : multiplicative G →ₙ* add_monoid_algebra k G | { to_fun := λ a, single a 1,
map_mul' := λ a b, by simpa only [mul_def, mul_one, sum_single_index, single_eq_zero, mul_zero], } | def | add_monoid_algebra.of_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",
"mul_one",
"mul_zero",
"multiplicative"
] | The embedding of an additive magma into its additive magma algebra. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
of [add_zero_class G] : multiplicative G →* add_monoid_algebra k G | { to_fun := λ a, single a 1,
map_one' := rfl,
.. of_magma k G } | def | add_monoid_algebra.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"
] | [
"add_monoid_algebra",
"add_zero_class",
"multiplicative"
] | Embedding of a magma with zero into its magma algebra. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
of' : G → add_monoid_algebra k G | λ a, single a 1 | def | add_monoid_algebra.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"
] | [
"add_monoid_algebra"
] | Embedding of a magma with zero `G`, into its magma algebra, having `G` as source. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
of_apply [add_zero_class G] (a : multiplicative G) : of k G a = single a.to_add 1 | rfl | lemma | add_monoid_algebra.of_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_zero_class",
"multiplicative"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of'_apply (a : G) : of' k G a = single a 1 | rfl | lemma | add_monoid_algebra.of'_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"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of'_eq_of [add_zero_class G] (a : G) : of' k G a = of k G a | rfl | lemma | add_monoid_algebra.of'_eq_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"
] | [
"add_zero_class"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of_injective [nontrivial k] [add_zero_class G] : function.injective (of k G) | λ a b h, by simpa using (single_eq_single_iff _ _ _ _).mp h | lemma | add_monoid_algebra.of_injective | 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_zero_class",
"nontrivial"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_hom [add_zero_class G] : k × multiplicative G →* add_monoid_algebra k G | { to_fun := λ a, single a.2.to_add a.1,
map_one' := rfl,
map_mul' := λ a b, single_mul_single.symm } | def | add_monoid_algebra.single_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",
"add_zero_class",
"multiplicative"
] | `finsupp.single` as a `monoid_hom` from the product type into the additive monoid algebra.
Note the order of the elements of the product are reversed compared to the arguments of
`finsupp.single`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mul_single_apply_aux [has_add G] (f : add_monoid_algebra k G) (r : k)
(x y z : G) (H : ∀ a, a + x = z ↔ a = y) :
(f * single x r) z = f y * r | @monoid_algebra.mul_single_apply_aux k (multiplicative G) _ _ _ _ _ _ _ H | lemma | add_monoid_algebra.mul_single_apply_aux | 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.mul_single_apply_aux",
"multiplicative"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_single_zero_apply [add_zero_class G] (f : add_monoid_algebra k G) (r : k) (x : G) :
(f * single 0 r) x = f x * r | f.mul_single_apply_aux r _ _ _ $ λ a, by rw [add_zero] | lemma | add_monoid_algebra.mul_single_zero_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",
"add_zero_class"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_single_apply_of_not_exists_add [has_add G] (r : k) {g g' : G} (x : add_monoid_algebra k G)
(h : ¬∃ d, g' = d + g):
(x * finsupp.single g r : add_monoid_algebra k G) g' = 0 | @monoid_algebra.mul_single_apply_of_not_exists_mul k (multiplicative G) _ _ _ _ _ _ h | lemma | add_monoid_algebra.mul_single_apply_of_not_exists_add | 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",
"monoid_algebra.mul_single_apply_of_not_exists_mul",
"multiplicative"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_mul_apply_aux [has_add G] (f : add_monoid_algebra k G) (r : k) (x y z : G)
(H : ∀ a, x + a = y ↔ a = z) :
(single x r * f : add_monoid_algebra k G) y = r * f z | @monoid_algebra.single_mul_apply_aux k (multiplicative G) _ _ _ _ _ _ _ H | lemma | add_monoid_algebra.single_mul_apply_aux | 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.single_mul_apply_aux",
"multiplicative"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_zero_mul_apply [add_zero_class G] (f : add_monoid_algebra k G) (r : k) (x : G) :
(single 0 r * f : add_monoid_algebra k G) x = r * f x | f.single_mul_apply_aux r _ _ _ $ λ a, by rw [zero_add] | lemma | add_monoid_algebra.single_zero_mul_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",
"add_zero_class"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_mul_apply_of_not_exists_add [has_add G] (r : k) {g g' : G} (x : add_monoid_algebra k G)
(h : ¬∃ d, g' = g + d):
(finsupp.single g r * x : add_monoid_algebra k G) g' = 0 | @monoid_algebra.single_mul_apply_of_not_exists_mul k (multiplicative G) _ _ _ _ _ _ h | lemma | add_monoid_algebra.single_mul_apply_of_not_exists_add | 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",
"monoid_algebra.single_mul_apply_of_not_exists_mul",
"multiplicative"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_single_apply [add_group G] (f : add_monoid_algebra k G) (r : k) (x y : G) :
(f * single x r) y = f (y - x) * r | (sub_eq_add_neg y x).symm ▸
@monoid_algebra.mul_single_apply k (multiplicative G) _ _ _ _ _ _ | lemma | add_monoid_algebra.mul_single_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_group",
"add_monoid_algebra",
"monoid_algebra.mul_single_apply",
"multiplicative"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
single_mul_apply [add_group G] (r : k) (x : G) (f : add_monoid_algebra k G) (y : G) :
(single x r * f : add_monoid_algebra k G) y = r * f (- x + y) | @monoid_algebra.single_mul_apply k (multiplicative G) _ _ _ _ _ _ | lemma | add_monoid_algebra.single_mul_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_group",
"add_monoid_algebra",
"monoid_algebra.single_mul_apply",
"multiplicative"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift_nc_smul {R : Type*} [add_zero_class G] [semiring R] (f : k →+* R)
(g : multiplicative G →* R) (c : k) (φ : monoid_algebra k G) :
lift_nc (f : k →+ R) g (c • φ) = f c * lift_nc (f : k →+ R) g φ | @monoid_algebra.lift_nc_smul k (multiplicative G) _ _ _ _ f g c φ | lemma | add_monoid_algebra.lift_nc_smul | 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_zero_class",
"monoid_algebra",
"monoid_algebra.lift_nc_smul",
"multiplicative",
"semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
induction_on [add_monoid G] {p : add_monoid_algebra k G → Prop} (f : add_monoid_algebra k G)
(hM : ∀ g, p (of k G (multiplicative.of_add g)))
(hadd : ∀ f g : add_monoid_algebra k G, p f → p g → p (f + g))
(hsmul : ∀ (r : k) f, p f → p (r • f)) : p f | begin
refine finsupp.induction_linear f _ (λ f g hf hg, hadd f g hf hg) (λ g r, _),
{ simpa using hsmul 0 (of k G (multiplicative.of_add 0)) (hM 0) },
{ convert hsmul r (of k G (multiplicative.of_add g)) (hM g),
simp only [mul_one, to_add_of_add, smul_single', of_apply] },
end | lemma | add_monoid_algebra.induction_on | 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.induction_linear",
"mul_one",
"multiplicative.of_add",
"to_add_of_add"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_domain_ring_hom (k : Type*) [semiring k] {H F : Type*} [add_monoid G] [add_monoid H]
[add_monoid_hom_class F G H] (f : F) :
add_monoid_algebra k G →+* add_monoid_algebra k H | { map_one' := map_domain_one f,
map_mul' := λ x y, map_domain_mul f x y,
..(finsupp.map_domain.add_monoid_hom f : monoid_algebra k G →+ monoid_algebra k H) } | def | add_monoid_algebra.map_domain_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",
"add_monoid_hom_class",
"finsupp.map_domain.add_monoid_hom",
"monoid_algebra",
"semiring"
] | If `f : G → H` is an additive homomorphism between two additive monoids, then
`finsupp.map_domain f` is a ring homomorphism between their add monoid algebras. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
add_monoid_algebra.to_multiplicative [semiring k] [has_add G] :
add_monoid_algebra k G ≃+* monoid_algebra k (multiplicative G) | { to_fun := equiv_map_domain multiplicative.of_add,
map_mul' := λ x y, begin
repeat {rw equiv_map_domain_eq_map_domain},
dsimp [multiplicative.of_add],
convert monoid_algebra.map_domain_mul (mul_hom.id (multiplicative G)) _ _,
end,
..finsupp.dom_congr multiplicative.of_add } | def | add_monoid_algebra.to_multiplicative | 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.dom_congr",
"monoid_algebra",
"monoid_algebra.map_domain_mul",
"mul_hom.id",
"multiplicative",
"multiplicative.of_add",
"semiring"
] | The equivalence between `add_monoid_algebra` and `monoid_algebra` in terms of
`multiplicative` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
monoid_algebra.to_additive [semiring k] [has_mul G] :
monoid_algebra k G ≃+* add_monoid_algebra k (additive G) | { to_fun := equiv_map_domain additive.of_mul,
map_mul' := λ x y, begin
repeat {rw equiv_map_domain_eq_map_domain},
dsimp [additive.of_mul],
convert monoid_algebra.map_domain_mul (mul_hom.id G) _ _,
end,
..finsupp.dom_congr additive.of_mul } | def | monoid_algebra.to_additive | 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",
"additive.of_mul",
"finsupp.dom_congr",
"monoid_algebra",
"monoid_algebra.map_domain_mul",
"mul_hom.id",
"semiring"
] | The equivalence between `monoid_algebra` and `add_monoid_algebra` in terms of `additive` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
is_scalar_tower_self [is_scalar_tower R k k] :
is_scalar_tower R (add_monoid_algebra k G) (add_monoid_algebra k G) | @monoid_algebra.is_scalar_tower_self k (multiplicative G) R _ _ _ _ | instance | add_monoid_algebra.is_scalar_tower_self | 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",
"is_scalar_tower",
"monoid_algebra.is_scalar_tower_self",
"multiplicative"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
smul_comm_class_self [smul_comm_class R k k] :
smul_comm_class R (add_monoid_algebra k G) (add_monoid_algebra k G) | @monoid_algebra.smul_comm_class_self k (multiplicative G) R _ _ _ _ | instance | add_monoid_algebra.smul_comm_class_self | 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.smul_comm_class_self",
"multiplicative",
"smul_comm_class",
"smul_comm_class_self"
] | Note that if `k` is a `comm_semiring` then we have `smul_comm_class k k k` and so we can take
`R = k` in the below. In other words, if the coefficients are commutative amongst themselves, they
also commute with the algebra multiplication. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
smul_comm_class_symm_self [smul_comm_class k R k] :
smul_comm_class (add_monoid_algebra k G) R (add_monoid_algebra k G) | @monoid_algebra.smul_comm_class_symm_self k (multiplicative G) R _ _ _ _ | instance | add_monoid_algebra.smul_comm_class_symm_self | 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.smul_comm_class_symm_self",
"multiplicative",
"smul_comm_class"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
non_unital_alg_hom_ext [distrib_mul_action k A]
{φ₁ φ₂ : add_monoid_algebra k G →ₙₐ[k] A}
(h : ∀ x, φ₁ (single x 1) = φ₂ (single x 1)) : φ₁ = φ₂ | @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"
] | A non_unital `k`-algebra homomorphism from `add_monoid_algebra k G` is uniquely defined by its
values on the functions `single a 1`. | 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.