statement stringlengths 1 2.93k | proof stringlengths 0 19.2k | type stringclasses 13
values | symbolic_name stringlengths 1 131 | library stringlengths 4 62 | filename stringlengths 20 95 | imports listlengths 0 10 | deps listlengths 0 64 | docstring stringlengths 0 4.95k | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
lift_unique (f : X → A) (F : FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A) :
F ∘ of R = f ↔ F = lift R f | (lift R).symm_apply_eq | theorem | FreeNonUnitalNonAssocAlgebra.lift_unique | Algebra | Mathlib/Algebra/FreeNonUnitalNonAssocAlgebra.lean | [] | [
"FreeNonUnitalNonAssocAlgebra"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
lift_of_apply (f : X → A) (x) : lift R f (of R x) = f x | congr_fun (of_comp_lift _ f) x | theorem | FreeNonUnitalNonAssocAlgebra.lift_of_apply | Algebra | Mathlib/Algebra/FreeNonUnitalNonAssocAlgebra.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
lift_comp_of (F : FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A) : lift R (F ∘ of R) = F | (lift R).apply_symm_apply F | theorem | FreeNonUnitalNonAssocAlgebra.lift_comp_of | Algebra | Mathlib/Algebra/FreeNonUnitalNonAssocAlgebra.lean | [] | [
"FreeNonUnitalNonAssocAlgebra"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
hom_ext {F₁ F₂ : FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A}
(h : ∀ x, F₁ (of R x) = F₂ (of R x)) : F₁ = F₂ | (lift R).symm.injective <| funext h | theorem | FreeNonUnitalNonAssocAlgebra.hom_ext | Algebra | Mathlib/Algebra/FreeNonUnitalNonAssocAlgebra.lean | [] | [
"FreeNonUnitalNonAssocAlgebra"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
GradedMonoid (A : ι → Type*) | Sigma A | def | GradedMonoid | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | A type alias of sigma types for graded monoids. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
mk {A : ι → Type*} : ∀ i, A i → GradedMonoid A | Sigma.mk | def | GradedMonoid.mk | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid"
] | Construct an element of a graded monoid. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
fst_smul [∀ i, SMul α (A i)] (a : α) (x : GradedMonoid A) :
(a • x).fst = x.fst | rfl | theorem | GradedMonoid.fst_smul | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
snd_smul [∀ i, SMul α (A i)] (a : α) (x : GradedMonoid A) :
(a • x).snd = a • x.snd | rfl | theorem | GradedMonoid.snd_smul | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
smul_mk [∀ i, SMul α (A i)] {i} (c : α) (a : A i) :
c • mk i a = mk i (c • a) | rfl | theorem | GradedMonoid.smul_mk | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
GOne [Zero ι] where
/-- The term `one` of grade 0 -/
one : A 0 | class | GradedMonoid.GOne | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | A graded version of `One`, which must be of grade 0. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
GOne.toOne [Zero ι] [GOne A] : One (GradedMonoid A) | ⟨⟨_, GOne.one⟩⟩ | instance | GradedMonoid.GOne.toOne | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid"
] | `GOne` implies `One (GradedMonoid A)` | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
fst_one [Zero ι] [GOne A] : (1 : GradedMonoid A).fst = 0 | rfl | theorem | GradedMonoid.fst_one | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
snd_one [Zero ι] [GOne A] : (1 : GradedMonoid A).snd = GOne.one | rfl | theorem | GradedMonoid.snd_one | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
GMul [Add ι] where
/-- The homogeneous multiplication map `mul` -/
mul {i j} : A i → A j → A (i + j) | class | GradedMonoid.GMul | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | A graded version of `Mul`. Multiplication combines grades additively, like
`AddMonoidAlgebra`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
GMul.toMul [Add ι] [GMul A] : Mul (GradedMonoid A) | ⟨fun x y => ⟨_, GMul.mul x.snd y.snd⟩⟩ | instance | GradedMonoid.GMul.toMul | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid"
] | `GMul` implies `Mul (GradedMonoid A)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
fst_mul [Add ι] [GMul A] (x y : GradedMonoid A) :
(x * y).fst = x.fst + y.fst | rfl | theorem | GradedMonoid.fst_mul | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
snd_mul [Add ι] [GMul A] (x y : GradedMonoid A) :
(x * y).snd = GMul.mul x.snd y.snd | rfl | theorem | GradedMonoid.snd_mul | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
mk_mul_mk [Add ι] [GMul A] {i j} (a : A i) (b : A j) :
mk i a * mk j b = mk (i + j) (GMul.mul a b) | rfl | theorem | GradedMonoid.mk_mul_mk | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
gnpowRec : ∀ (n : ℕ) {i}, A i → A (n • i) | | 0, i, _ => cast (congr_arg A (zero_nsmul i).symm) GOne.one
| n + 1, i, a => cast (congr_arg A (succ_nsmul i n).symm) (GMul.mul (gnpowRec _ a) a) | def | GradedMonoid.GMonoid.gnpowRec | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"symm"
] | A default implementation of power on a graded monoid, like `npowRec`.
`GMonoid.gnpow` should be used instead. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
gnpowRec_zero (a : GradedMonoid A) : GradedMonoid.mk _ (gnpowRec 0 a.snd) = 1 | Sigma.ext (zero_nsmul _) (heq_of_cast_eq _ rfl).symm | theorem | GradedMonoid.GMonoid.gnpowRec_zero | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid",
"GradedMonoid.mk",
"symm"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
gnpowRec_succ (n : ℕ) (a : GradedMonoid A) :
(GradedMonoid.mk _ <| gnpowRec n.succ a.snd) = ⟨_, gnpowRec n a.snd⟩ * a | Sigma.ext (succ_nsmul _ _) (heq_of_cast_eq _ rfl).symm | theorem | GradedMonoid.GMonoid.gnpowRec_succ | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid",
"GradedMonoid.mk",
"symm"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
"apply_gmonoid_gnpowRec_zero_tac" : tactic => `(tactic| apply GMonoid.gnpowRec_zero) | macro | apply_gmonoid_gnpowRec_zero_tac | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | A tactic to for use as an optional value for `GMonoid.gnpow_zero'`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
"apply_gmonoid_gnpowRec_succ_tac" : tactic => `(tactic| apply GMonoid.gnpowRec_succ) | macro | apply_gmonoid_gnpowRec_succ_tac | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | A tactic to for use as an optional value for `GMonoid.gnpow_succ'`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
GMonoid [AddMonoid ι] extends GMul A, GOne A where
/-- Multiplication by `one` on the left is the identity -/
one_mul (a : GradedMonoid A) : 1 * a = a
/-- Multiplication by `one` on the right is the identity -/
mul_one (a : GradedMonoid A) : a * 1 = a
/-- Multiplication is associative -/
mul_assoc (a b c : ... | GMonoid.gnpowRec
/-- The zeroth power will yield 1 -/
gnpow_zero' : ∀ a : GradedMonoid A, GradedMonoid.mk _ (gnpow 0 a.snd) = 1 := by
apply_gmonoid_gnpowRec_zero_tac
/-- Successor powers behave as expected -/
gnpow_succ' :
∀ (n : ℕ) (a : GradedMonoid A),
(GradedMonoid.mk _ <| gnpow n.succ a.snd) =... | class | GradedMonoid.GMonoid | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"AddMonoid",
"GradedMonoid",
"GradedMonoid.mk",
"mul_assoc",
"mul_one",
"one_mul"
] | A graded version of `Monoid`
Like `Monoid.npow`, this has an optional `GMonoid.gnpow` field to allow definitional control of
natural powers of a graded monoid. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
GMonoid.toMonoid [AddMonoid ι] [GMonoid A] : Monoid (GradedMonoid A) | where
npow n a := GradedMonoid.mk _ (GMonoid.gnpow n a.snd)
npow_zero a := GMonoid.gnpow_zero' a
npow_succ n a := GMonoid.gnpow_succ' n a
one_mul := GMonoid.one_mul
mul_one := GMonoid.mul_one
mul_assoc := GMonoid.mul_assoc | instance | GradedMonoid.GMonoid.toMonoid | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"AddMonoid",
"GradedMonoid",
"GradedMonoid.mk",
"Monoid",
"mul_assoc",
"mul_one",
"npow_zero",
"one_mul"
] | `GMonoid` implies a `Monoid (GradedMonoid A)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
fst_pow [AddMonoid ι] [GMonoid A] (x : GradedMonoid A) (n : ℕ) :
(x ^ n).fst = n • x.fst | rfl | theorem | GradedMonoid.fst_pow | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"AddMonoid",
"GradedMonoid"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
snd_pow [AddMonoid ι] [GMonoid A] (x : GradedMonoid A) (n : ℕ) :
(x ^ n).snd = GMonoid.gnpow n x.snd | rfl | theorem | GradedMonoid.snd_pow | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"AddMonoid",
"GradedMonoid"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
mk_pow [AddMonoid ι] [GMonoid A] {i} (a : A i) (n : ℕ) :
mk i a ^ n = mk (n • i) (GMonoid.gnpow _ a) | rfl | theorem | GradedMonoid.mk_pow | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"AddMonoid"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
GCommMonoid [AddCommMonoid ι] extends GMonoid A where
/-- Multiplication is commutative -/
mul_comm (a : GradedMonoid A) (b : GradedMonoid A) : a * b = b * a | class | GradedMonoid.GCommMonoid | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"AddCommMonoid",
"GradedMonoid",
"mul_comm"
] | A graded version of `CommMonoid`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
GCommMonoid.toCommMonoid [AddCommMonoid ι] [GCommMonoid A] :
CommMonoid (GradedMonoid A) | where
mul_comm := GCommMonoid.mul_comm | instance | GradedMonoid.GCommMonoid.toCommMonoid | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"AddCommMonoid",
"CommMonoid",
"GradedMonoid",
"mul_comm"
] | `GCommMonoid` implies a `CommMonoid (GradedMonoid A)`, although this is only used as an
instance locally to define notation in `gmonoid` and similar typeclasses. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
GradeZero.smul (i : ι) : SMul (A 0) (A i) | where
smul x y := @Eq.rec ι (0 + i) (fun a _ => A a) (GMul.mul x y) i (zero_add i) | instance | GradedMonoid.GradeZero.smul | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | `(•) : A 0 → A i → A i` is the value provided in `GradedMonoid.GMul.mul`, composed with
an `Eq.rec` to turn `A (0 + i)` into `A i`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
mk_zero_smul {i} (a : A 0) (b : A i) : mk _ (a • b) = mk _ a * mk _ b | Sigma.ext (zero_add _).symm <| eqRec_heq _ _ | theorem | GradedMonoid.mk_zero_smul | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"symm"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
GradeZero.smul_eq_mul (a b : A 0) : a • b = a * b | rfl | theorem | GradedMonoid.GradeZero.smul_eq_mul | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
mk_zero_pow (a : A 0) (n : ℕ) : mk _ (a ^ n) = mk _ a ^ n | Sigma.ext (nsmul_zero n).symm <| eqRec_heq _ _ | theorem | GradedMonoid.mk_zero_pow | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"symm"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
mkZeroMonoidHom : A 0 →* GradedMonoid A | where
toFun := mk 0
map_one' := rfl
map_mul' := mk_zero_smul | def | GradedMonoid.mkZeroMonoidHom | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid"
] | `GradedMonoid.mk 0` is a `MonoidHom`, using the `GradedMonoid.GradeZero.monoid` structure. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
GradeZero.mulAction {i} : MulAction (A 0) (A i) | letI := MulAction.compHom (GradedMonoid A) (mkZeroMonoidHom A)
Function.Injective.mulAction (mk i) sigma_mk_injective mk_zero_smul | instance | GradedMonoid.GradeZero.mulAction | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"Function.Injective.mulAction",
"GradedMonoid",
"MulAction",
"MulAction.compHom",
"sigma_mk_injective"
] | Each grade `A i` derives an `A 0`-action structure from `GMonoid A`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
List.dProdIndex (l : List α) (fι : α → ι) : ι | l.foldr (fun i b => fι i + b) 0 | def | List.dProdIndex | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | The index used by `List.dProd`. Propositionally this is equal to `(l.map fι).Sum`, but
definitionally it needs to have a different form to avoid introducing `Eq.rec`s in `List.dProd`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
List.dProdIndex_nil (fι : α → ι) : ([] : List α).dProdIndex fι = 0 | rfl | theorem | List.dProdIndex_nil | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
List.dProdIndex_cons (a : α) (l : List α) (fι : α → ι) :
(a :: l).dProdIndex fι = fι a + l.dProdIndex fι | rfl | theorem | List.dProdIndex_cons | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
List.dProdIndex_eq_map_sum (l : List α) (fι : α → ι) :
l.dProdIndex fι = (l.map fι).sum | by
match l with
| [] => simp
| head::tail => simp [List.dProdIndex_eq_map_sum tail fι] | theorem | List.dProdIndex_eq_map_sum | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
List.dProd (l : List α) (fι : α → ι) (fA : ∀ a, A (fι a)) : A (l.dProdIndex fι) | l.foldrRecOn _ GradedMonoid.GOne.one fun _ x a _ => GradedMonoid.GMul.mul (fA a) x | def | List.dProd | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | A dependent product for graded monoids represented by the indexed family of types `A i`.
This is a dependent version of `(l.map fA).prod`.
For a list `l : List α`, this computes the product of `fA a` over `a`, where each `fA` is of type
`A (fι a)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
List.dProd_nil (fι : α → ι) (fA : ∀ a, A (fι a)) :
(List.nil : List α).dProd fι fA = GradedMonoid.GOne.one | rfl | theorem | List.dProd_nil | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
List.dProd_cons (fι : α → ι) (fA : ∀ a, A (fι a)) (a : α) (l : List α) :
(a :: l).dProd fι fA = (GradedMonoid.GMul.mul (fA a) (l.dProd fι fA) :) | rfl | theorem | List.dProd_cons | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
GradedMonoid.mk_list_dProd (l : List α) (fι : α → ι) (fA : ∀ a, A (fι a)) :
GradedMonoid.mk _ (l.dProd fι fA) = (l.map fun a => GradedMonoid.mk (fι a) (fA a)).prod | by
match l with
| [] => simp only [List.dProdIndex_nil, List.dProd_nil, List.map_nil, List.prod_nil]; rfl
| head::tail =>
simp [← GradedMonoid.mk_list_dProd tail _ _, GradedMonoid.mk_mul_mk, List.prod_cons] | theorem | GradedMonoid.mk_list_dProd | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid.mk",
"GradedMonoid.mk_mul_mk",
"List.dProdIndex_nil",
"List.dProd_nil"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
GradedMonoid.list_prod_map_eq_dProd (l : List α) (f : α → GradedMonoid A) :
(l.map f).prod = GradedMonoid.mk _ (l.dProd (fun i => (f i).1) fun i => (f i).2) | by
rw [GradedMonoid.mk_list_dProd, GradedMonoid.mk]
simp_rw [Sigma.eta] | theorem | GradedMonoid.list_prod_map_eq_dProd | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid",
"GradedMonoid.mk",
"GradedMonoid.mk_list_dProd",
"Sigma.eta"
] | A variant of `GradedMonoid.mk_list_dProd` for rewriting in the other direction. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
GradedMonoid.list_prod_ofFn_eq_dProd {n : ℕ} (f : Fin n → GradedMonoid A) :
(List.ofFn f).prod =
GradedMonoid.mk _ ((List.finRange n).dProd (fun i => (f i).1) fun i => (f i).2) | by
rw [List.ofFn_eq_map, GradedMonoid.list_prod_map_eq_dProd] | theorem | GradedMonoid.list_prod_ofFn_eq_dProd | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid",
"GradedMonoid.list_prod_map_eq_dProd",
"GradedMonoid.mk",
"List.ofFn_eq_map"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
One.gOne [Zero ι] [One R] : GradedMonoid.GOne fun _ : ι => R | where one := 1 | instance | One.gOne | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid.GOne"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Mul.gMul [Add ι] [Mul R] : GradedMonoid.GMul fun _ : ι => R | where mul x y := x * y | instance | Mul.gMul | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid.GMul"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Monoid.gMonoid [AddMonoid ι] [Monoid R] : GradedMonoid.GMonoid fun _ : ι => R | where
one_mul := fun _ => Sigma.ext (zero_add _) (heq_of_eq (one_mul _))
mul_one := fun _ => Sigma.ext (add_zero _) (heq_of_eq (mul_one _))
mul_assoc := fun _ _ _ => Sigma.ext (add_assoc _ _ _) (heq_of_eq (mul_assoc _ _ _))
gnpow := fun n _ a => a ^ n
gnpow_zero' := fun _ => Sigma.ext (zero_nsmul _) (heq_of_e... | instance | Monoid.gMonoid | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"AddMonoid",
"GradedMonoid.GMonoid",
"Monoid",
"mul_assoc",
"mul_one",
"one_mul"
] | If all grades are the same type and themselves form a monoid, then there is a trivial grading
structure. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
CommMonoid.gCommMonoid [AddCommMonoid ι] [CommMonoid R] :
GradedMonoid.GCommMonoid fun _ : ι => R | where
mul_comm := fun _ _ => Sigma.ext (add_comm _ _) (heq_of_eq (mul_comm _ _)) | instance | CommMonoid.gCommMonoid | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"AddCommMonoid",
"CommMonoid",
"GradedMonoid.GCommMonoid",
"mul_comm"
] | If all grades are the same type and themselves form a commutative monoid, then there is a
trivial grading structure. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
List.dProd_monoid {α} [AddMonoid ι] [Monoid R] (l : List α) (fι : α → ι) (fA : α → R) :
@List.dProd _ _ (fun _ : ι => R) _ _ l fι fA = (l.map fA).prod | by
match l with
| [] =>
rw [List.dProd_nil, List.map_nil, List.prod_nil]
rfl
| head::tail =>
rw [List.dProd_cons, List.map_cons, List.prod_cons, List.dProd_monoid tail _ _]
rfl | theorem | List.dProd_monoid | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"AddMonoid",
"List.dProd",
"List.dProd_cons",
"List.dProd_nil",
"Monoid"
] | When all the indexed types are the same, the dependent product is just the regular product. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
SetLike.GradedOne {S : Type*} [SetLike S R] [One R] [Zero ι] (A : ι → S) : Prop where
/-- One has grade zero -/
one_mem : (1 : R) ∈ A 0 | class | SetLike.GradedOne | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"SetLike"
] | A version of `GradedMonoid.GOne` for internally graded objects. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.one_mem_graded {S : Type*} [SetLike S R] [One R] [Zero ι] (A : ι → S)
[SetLike.GradedOne A] : (1 : R) ∈ A 0 | SetLike.GradedOne.one_mem | theorem | SetLike.one_mem_graded | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"SetLike",
"SetLike.GradedOne"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.gOne {S : Type*} [SetLike S R] [One R] [Zero ι] (A : ι → S)
[SetLike.GradedOne A] : GradedMonoid.GOne fun i => A i | where
one := ⟨1, SetLike.one_mem_graded _⟩ | instance | SetLike.gOne | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid.GOne",
"SetLike",
"SetLike.GradedOne",
"SetLike.one_mem_graded"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.coe_gOne {S : Type*} [SetLike S R] [One R] [Zero ι] (A : ι → S)
[SetLike.GradedOne A] : ↑(@GradedMonoid.GOne.one _ (fun i => A i) _ _) = (1 : R) | rfl | theorem | SetLike.coe_gOne | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"SetLike",
"SetLike.GradedOne"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.GradedMul {S : Type*} [SetLike S R] [Mul R] [Add ι] (A : ι → S) : Prop where
/-- Multiplication is homogeneous -/
mul_mem : ∀ ⦃i j⦄ {gi gj}, gi ∈ A i → gj ∈ A j → gi * gj ∈ A (i + j) | class | SetLike.GradedMul | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"SetLike"
] | A version of `GradedMonoid.ghas_one` for internally graded objects. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.mul_mem_graded {S : Type*} [SetLike S R] [Mul R] [Add ι] {A : ι → S}
[SetLike.GradedMul A] ⦃i j⦄ {gi gj} (hi : gi ∈ A i) (hj : gj ∈ A j) : gi * gj ∈ A (i + j) | SetLike.GradedMul.mul_mem hi hj | theorem | SetLike.mul_mem_graded | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"SetLike",
"SetLike.GradedMul"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.gMul {S : Type*} [SetLike S R] [Mul R] [Add ι] (A : ι → S)
[SetLike.GradedMul A] : GradedMonoid.GMul fun i => A i | where
mul := fun a b => ⟨(a * b : R), SetLike.mul_mem_graded a.prop b.prop⟩ | instance | SetLike.gMul | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"GradedMonoid.GMul",
"SetLike",
"SetLike.GradedMul",
"SetLike.mul_mem_graded"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.coe_gMul {S : Type*} [SetLike S R] [Mul R] [Add ι] (A : ι → S)
[SetLike.GradedMul A] {i j : ι} (x : A i) (y : A j) :
↑(@GradedMonoid.GMul.mul _ (fun i => A i) _ _ _ _ x y) = (x * y : R) | rfl | theorem | SetLike.coe_gMul | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"SetLike",
"SetLike.GradedMul"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.GradedMonoid {S : Type*} [SetLike S R] [Monoid R] [AddMonoid ι] (A : ι → S) : Prop
extends SetLike.GradedOne A, SetLike.GradedMul A | class | SetLike.GradedMonoid | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"AddMonoid",
"Monoid",
"SetLike",
"SetLike.GradedMul",
"SetLike.GradedOne"
] | A version of `GradedMonoid.GMonoid` for internally graded objects. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
submonoid : Submonoid R | where
carrier := A 0
mul_mem' ha hb := add_zero (0 : ι) ▸ SetLike.mul_mem_graded ha hb
one_mem' := SetLike.one_mem_graded A | def | SetLike.GradeZero.submonoid | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"SetLike.mul_mem_graded",
"SetLike.one_mem_graded",
"Submonoid"
] | The submonoid `A 0` of `R`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
instMonoid : Monoid (A 0) | inferInstanceAs <| Monoid (GradeZero.submonoid A) | instance | SetLike.GradeZero.instMonoid | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"Monoid"
] | The monoid `A 0` inherited from `R` in the presence of `SetLike.GradedMonoid A`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
instCommMonoid
{R S : Type*} [SetLike S R] [CommMonoid R]
{A : ι → S} [SetLike.GradedMonoid A] :
CommMonoid (A 0) | inferInstanceAs <| CommMonoid (GradeZero.submonoid A) | instance | SetLike.GradeZero.instCommMonoid | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"CommMonoid",
"SetLike",
"SetLike.GradedMonoid"
] | The commutative monoid `A 0` inherited from `R` in the presence of `SetLike.GradedMonoid A`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
coe_one : ↑(1 : A 0) = (1 : R) | rfl | theorem | SetLike.GradeZero.coe_one | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
coe_mul (a b : A 0) : ↑(a * b) = (↑a * ↑b : R) | rfl | theorem | SetLike.GradeZero.coe_mul | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
coe_pow (a : A 0) (n : ℕ) : ↑(a ^ n) = (↑a : R) ^ n | rfl | theorem | SetLike.GradeZero.coe_pow | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
pow_mem_graded (n : ℕ) {r : R} {i : ι} (h : r ∈ A i) : r ^ n ∈ A (n • i) | by
match n with
| 0 =>
rw [pow_zero, zero_nsmul]
exact one_mem_graded _
| n + 1 =>
rw [pow_succ', succ_nsmul']
exact mul_mem_graded h (pow_mem_graded n h) | theorem | SetLike.pow_mem_graded | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"pow_succ'",
"pow_zero"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
list_prod_map_mem_graded {ι'} (l : List ι') (i : ι' → ι) (r : ι' → R)
(h : ∀ j ∈ l, r j ∈ A (i j)) : (l.map r).prod ∈ A (l.map i).sum | by
match l with
| [] =>
rw [List.map_nil, List.map_nil, List.prod_nil, List.sum_nil]
exact one_mem_graded _
| head::tail =>
rw [List.map_cons, List.map_cons, List.prod_cons, List.sum_cons]
exact
mul_mem_graded (h _ List.mem_cons_self)
(list_prod_map_mem_graded tail _ _ fun j hj => h ... | theorem | SetLike.list_prod_map_mem_graded | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
list_prod_ofFn_mem_graded {n} (i : Fin n → ι) (r : Fin n → R) (h : ∀ j, r j ∈ A (i j)) :
(List.ofFn r).prod ∈ A (List.ofFn i).sum | by
rw [List.ofFn_eq_map, List.ofFn_eq_map]
exact list_prod_map_mem_graded _ _ _ fun _ _ => h _ | theorem | SetLike.list_prod_ofFn_mem_graded | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"List.ofFn_eq_map"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.gMonoid {S : Type*} [SetLike S R] [Monoid R] [AddMonoid ι] (A : ι → S)
[SetLike.GradedMonoid A] : GradedMonoid.GMonoid fun i => A i | where
one_mul := fun ⟨_, _, _⟩ => Sigma.subtype_ext (zero_add _) (one_mul _)
mul_one := fun ⟨_, _, _⟩ => Sigma.subtype_ext (add_zero _) (mul_one _)
mul_assoc := fun ⟨_, _, _⟩ ⟨_, _, _⟩ ⟨_, _, _⟩ =>
Sigma.subtype_ext (add_assoc _ _ _) (mul_assoc _ _ _)
gnpow := fun n _ a => ⟨(a:R)^n, SetLike.pow_mem_graded n... | instance | SetLike.gMonoid | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"AddMonoid",
"GradedMonoid.GMonoid",
"Monoid",
"SetLike",
"SetLike.GradedMonoid",
"SetLike.pow_mem_graded",
"Sigma.subtype_ext",
"mul_assoc",
"mul_one",
"one_mul",
"pow_succ",
"pow_zero"
] | Build a `GMonoid` instance for a collection of subobjects. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
SetLike.coe_gnpow {S : Type*} [SetLike S R] [Monoid R] [AddMonoid ι] (A : ι → S)
[SetLike.GradedMonoid A] {i : ι} (x : A i) (n : ℕ) :
↑(@GradedMonoid.GMonoid.gnpow _ (fun i => A i) _ _ n _ x) = (x : R) ^ n | rfl | theorem | SetLike.coe_gnpow | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"AddMonoid",
"Monoid",
"SetLike",
"SetLike.GradedMonoid"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.gCommMonoid {S : Type*} [SetLike S R] [CommMonoid R] [AddCommMonoid ι] (A : ι → S)
[SetLike.GradedMonoid A] : GradedMonoid.GCommMonoid fun i => A i | where
mul_comm := fun ⟨_, _, _⟩ ⟨_, _, _⟩ => Sigma.subtype_ext (add_comm _ _) (mul_comm _ _) | instance | SetLike.gCommMonoid | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"AddCommMonoid",
"CommMonoid",
"GradedMonoid.GCommMonoid",
"SetLike",
"SetLike.GradedMonoid",
"Sigma.subtype_ext",
"mul_comm"
] | Build a `GCommMonoid` instance for a collection of subobjects. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
SetLike.coe_list_dProd (A : ι → S) [SetLike.GradedMonoid A] (fι : α → ι)
(fA : ∀ a, A (fι a)) (l : List α) : ↑(@List.dProd _ _ (fun i => ↥(A i)) _ _ l fι fA)
= (List.prod (l.map fun a => fA a) : R) | by
match l with
| [] =>
rw [List.dProd_nil, coe_gOne, List.map_nil, List.prod_nil]
| head::tail =>
rw [List.dProd_cons, coe_gMul, List.map_cons, List.prod_cons,
SetLike.coe_list_dProd _ _ _ tail] | theorem | SetLike.coe_list_dProd | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"List.dProd",
"List.dProd_cons",
"List.dProd_nil",
"SetLike.GradedMonoid"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.list_dProd_eq (A : ι → S) [SetLike.GradedMonoid A] (fι : α → ι) (fA : ∀ a, A (fι a))
(l : List α) :
(@List.dProd _ _ (fun i => ↥(A i)) _ _ l fι fA) =
⟨List.prod (l.map fun a => fA a),
(l.dProdIndex_eq_map_sum fι).symm ▸
list_prod_map_mem_graded l _ _ fun i _ => (fA i).prop⟩ | Subtype.ext <| SetLike.coe_list_dProd _ _ _ _ | theorem | SetLike.list_dProd_eq | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"List.dProd",
"SetLike.GradedMonoid",
"SetLike.coe_list_dProd",
"symm"
] | A version of `List.coe_dProd_set_like` with `Subtype.mk`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
SetLike.IsHomogeneousElem (A : ι → S) (a : R) : Prop | ∃ i, a ∈ A i | def | SetLike.IsHomogeneousElem | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | An element `a : R` is said to be homogeneous if there is some `i : ι` such that `a ∈ A i`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
SetLike.isHomogeneousElem_coe {A : ι → S} {i} (x : A i) :
SetLike.IsHomogeneousElem A (x : R) | ⟨i, x.prop⟩ | theorem | SetLike.isHomogeneousElem_coe | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"SetLike.IsHomogeneousElem"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.isHomogeneousElem_one [Zero ι] [One R] (A : ι → S) [SetLike.GradedOne A] :
SetLike.IsHomogeneousElem A (1 : R) | ⟨0, SetLike.one_mem_graded _⟩ | theorem | SetLike.isHomogeneousElem_one | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"SetLike.GradedOne",
"SetLike.IsHomogeneousElem",
"SetLike.one_mem_graded"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.IsHomogeneousElem.mul [Add ι] [Mul R] {A : ι → S} [SetLike.GradedMul A] {a b : R} :
SetLike.IsHomogeneousElem A a → SetLike.IsHomogeneousElem A b →
SetLike.IsHomogeneousElem A (a * b) | | ⟨i, hi⟩, ⟨j, hj⟩ => ⟨i + j, SetLike.mul_mem_graded hi hj⟩ | theorem | SetLike.IsHomogeneousElem.mul | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"SetLike.GradedMul",
"SetLike.IsHomogeneousElem",
"SetLike.mul_mem_graded"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.homogeneousSubmonoid [AddMonoid ι] [Monoid R] (A : ι → S) [SetLike.GradedMonoid A] :
Submonoid R | where
carrier := { a | SetLike.IsHomogeneousElem A a }
one_mem' := SetLike.isHomogeneousElem_one A
mul_mem' a b := SetLike.IsHomogeneousElem.mul a b | def | SetLike.homogeneousSubmonoid | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"AddMonoid",
"Monoid",
"SetLike.GradedMonoid",
"SetLike.IsHomogeneousElem",
"SetLike.IsHomogeneousElem.mul",
"SetLike.isHomogeneousElem_one",
"Submonoid"
] | When `A` is a `SetLike.GradedMonoid A`, then the homogeneous elements forms a submonoid. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
prod_mem_graded (hF : ∀ k ∈ F, g k ∈ A (i k)) : ∏ k ∈ F, g k ∈ A (∑ k ∈ F, i k) | by
classical
induction F using Finset.induction_on
· simp [GradedOne.one_mem]
· case insert j F' hF2 h3 =>
rw [Finset.prod_insert hF2, Finset.sum_insert hF2]
apply SetLike.mul_mem_graded (by grind)
grind | theorem | SetLike.prod_mem_graded | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [
"Finset.induction_on",
"Finset.prod_insert",
"SetLike.mul_mem_graded"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
prod_pow_mem_graded (n : κ → ℕ) (hF : ∀ k ∈ F, g k ∈ A (i k)) :
∏ k ∈ F, g k ^ n k ∈ A (∑ k ∈ F, n k • i k) | prod_mem_graded A _ _ fun k hk ↦ pow_mem_graded _ (hF k hk) | theorem | SetLike.prod_pow_mem_graded | Algebra | Mathlib/Algebra/GradedMonoid.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
GSMul [VAdd ιA ιM] where
/-- The homogeneous multiplication map `smul` -/
smul {i j} : A i → M j → M (i +ᵥ j) | class | GradedMonoid.GSMul | Algebra | Mathlib/Algebra/GradedMulAction.lean | [] | [
"VAdd"
] | A graded version of `SMul`. Scalar multiplication combines grades additively, i.e.
if `a ∈ A i` and `m ∈ M j`, then `a • b` must be in `M (i + j)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
GMul.toGSMul [Add ιA] [GMul A] : GSMul A A | where smul := GMul.mul | instance | GradedMonoid.GMul.toGSMul | Algebra | Mathlib/Algebra/GradedMulAction.lean | [] | [] | A graded version of `Mul.toSMul` | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
GSMul.toSMul [VAdd ιA ιM] [GSMul A M] : SMul (GradedMonoid A) (GradedMonoid M) | ⟨fun x y ↦ ⟨_, GSMul.smul x.snd y.snd⟩⟩ | instance | GradedMonoid.GSMul.toSMul | Algebra | Mathlib/Algebra/GradedMulAction.lean | [] | [
"GradedMonoid",
"VAdd"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
mk_smul_mk [VAdd ιA ιM] [GSMul A M] {i j} (a : A i) (b : M j) :
mk i a • mk j b = mk (i +ᵥ j) (GSMul.smul a b) | rfl | theorem | GradedMonoid.mk_smul_mk | Algebra | Mathlib/Algebra/GradedMulAction.lean | [] | [
"VAdd"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
GMulAction [AddMonoid ιA] [VAdd ιA ιM] [GMonoid A] extends GSMul A M where
/-- One is the neutral element for `•` -/
one_smul (b : GradedMonoid M) : (1 : GradedMonoid A) • b = b
/-- Associativity of `•` and `*` -/
mul_smul (a a' : GradedMonoid A) (b : GradedMonoid M) : (a * a') • b = a • a' • b | class | GradedMonoid.GMulAction | Algebra | Mathlib/Algebra/GradedMulAction.lean | [] | [
"AddMonoid",
"GradedMonoid",
"VAdd",
"one_smul"
] | A graded version of `MulAction`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
GMonoid.toGMulAction [AddMonoid ιA] [GMonoid A] : GMulAction A A | { GMul.toGSMul _ with
one_smul := GMonoid.one_mul
mul_smul := GMonoid.mul_assoc } | instance | GradedMonoid.GMonoid.toGMulAction | Algebra | Mathlib/Algebra/GradedMulAction.lean | [] | [
"AddMonoid",
"one_smul"
] | The graded version of `Monoid.toMulAction`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
GMulAction.toMulAction [AddMonoid ιA] [GMonoid A] [VAdd ιA ιM] [GMulAction A M] :
MulAction (GradedMonoid A) (GradedMonoid M) | where
one_smul := GMulAction.one_smul
mul_smul := GMulAction.mul_smul | instance | GradedMonoid.GMulAction.toMulAction | Algebra | Mathlib/Algebra/GradedMulAction.lean | [] | [
"AddMonoid",
"GradedMonoid",
"MulAction",
"VAdd",
"one_smul"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.GradedSMul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [VAdd ιA ιB]
(A : ιA → S) (B : ιB → N) : Prop where
/-- Multiplication is homogeneous -/
smul_mem : ∀ ⦃i : ιA⦄ ⦃j : ιB⦄ {ai bj}, ai ∈ A i → bj ∈ B j → ai • bj ∈ B (i +ᵥ j) | class | SetLike.GradedSMul | Algebra | Mathlib/Algebra/GradedMulAction.lean | [] | [
"SetLike",
"VAdd"
] | A version of `GradedMonoid.GSMul` for internally graded objects. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.toGSMul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [VAdd ιA ιB]
(A : ιA → S) (B : ιB → N) [SetLike.GradedSMul A B] :
GradedMonoid.GSMul (fun i ↦ A i) fun i ↦ B i | where
smul a b := ⟨a.1 • b.1, SetLike.GradedSMul.smul_mem a.2 b.2⟩ | instance | SetLike.toGSMul | Algebra | Mathlib/Algebra/GradedMulAction.lean | [] | [
"GradedMonoid.GSMul",
"SetLike",
"SetLike.GradedSMul",
"VAdd"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.coe_GSMul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [VAdd ιA ιB]
(A : ιA → S) (B : ιB → N) [SetLike.GradedSMul A B] {i : ιA} {j : ιB} (x : A i) (y : B j) :
(@GradedMonoid.GSMul.smul ιA ιB (fun i ↦ A i) (fun i ↦ B i) _ _ i j x y : M) = x.1 • y.1 | rfl | theorem | SetLike.coe_GSMul | Algebra | Mathlib/Algebra/GradedMulAction.lean | [] | [
"SetLike",
"SetLike.GradedSMul",
"VAdd"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SetLike.GradedMul.toGradedSMul [AddMonoid ιA] [Monoid R] {S : Type*} [SetLike S R]
(A : ιA → S) [SetLike.GradedMonoid A] : SetLike.GradedSMul A A | where
smul_mem _ _ _ _ hi hj := SetLike.GradedMonoid.toGradedMul.mul_mem hi hj | instance | SetLike.GradedMul.toGradedSMul | Algebra | Mathlib/Algebra/GradedMulAction.lean | [] | [
"AddMonoid",
"Monoid",
"SetLike",
"SetLike.GradedMonoid",
"SetLike.GradedSMul"
] | Internally graded version of `Mul.toSMul`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
SetLike.IsHomogeneousElem.graded_smul [VAdd ιA ιB] [SMul R M] {A : ιA → S} {B : ιB → N}
[SetLike.GradedSMul A B] {a : R} {b : M} :
SetLike.IsHomogeneousElem A a → SetLike.IsHomogeneousElem B b →
SetLike.IsHomogeneousElem B (a • b) | | ⟨i, hi⟩, ⟨j, hj⟩ => ⟨i +ᵥ j, SetLike.GradedSMul.smul_mem hi hj⟩ | theorem | SetLike.IsHomogeneousElem.graded_smul | Algebra | Mathlib/Algebra/GradedMulAction.lean | [] | [
"SetLike.GradedSMul",
"SetLike.IsHomogeneousElem",
"VAdd"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
IsPrimePow : Prop | ∃ (p : R) (k : ℕ), Prime p ∧ 0 < k ∧ p ^ k = n | def | IsPrimePow | Algebra | Mathlib/Algebra/IsPrimePow.lean | [] | [
"Prime"
] | `n` is a prime power if there is a prime `p` and a positive natural `k` such that `n` can be
written as `p^k`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isPrimePow_def : IsPrimePow n ↔ ∃ (p : R) (k : ℕ), Prime p ∧ 0 < k ∧ p ^ k = n | Iff.rfl | theorem | isPrimePow_def | Algebra | Mathlib/Algebra/IsPrimePow.lean | [] | [
"IsPrimePow",
"Prime"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isPrimePow_iff_pow_succ : IsPrimePow n ↔ ∃ (p : R) (k : ℕ), Prime p ∧ p ^ (k + 1) = n | (isPrimePow_def _).trans
⟨fun ⟨p, k, hp, hk, hn⟩ => ⟨p, k - 1, hp, by rwa [Nat.sub_add_cancel hk]⟩, fun ⟨_, _, hp, hn⟩ =>
⟨_, _, hp, Nat.succ_pos', hn⟩⟩ | theorem | isPrimePow_iff_pow_succ | Algebra | Mathlib/Algebra/IsPrimePow.lean | [] | [
"IsPrimePow",
"Nat.succ_pos'",
"Prime",
"isPrimePow_def",
"trans"
] | An equivalent definition for prime powers: `n` is a prime power iff there is a prime `p` and a
natural `k` such that `n` can be written as `p^(k+1)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
not_isPrimePow_zero [NoZeroDivisors R] : ¬IsPrimePow (0 : R) | by
simp only [isPrimePow_def, not_exists, not_and', and_imp]
intro x n _hn hx
rw [eq_zero_of_pow_eq_zero hx]
simp | theorem | not_isPrimePow_zero | Algebra | Mathlib/Algebra/IsPrimePow.lean | [] | [
"IsPrimePow",
"NoZeroDivisors",
"eq_zero_of_pow_eq_zero",
"isPrimePow_def"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
IsPrimePow.not_unit {n : R} (h : IsPrimePow n) : ¬IsUnit n | let ⟨_p, _k, hp, hk, hn⟩ := h
hn ▸ (isUnit_pow_iff hk.ne').not.mpr hp.not_unit | theorem | IsPrimePow.not_unit | Algebra | Mathlib/Algebra/IsPrimePow.lean | [] | [
"IsPrimePow",
"IsUnit",
"isUnit_pow_iff"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
IsUnit.not_isPrimePow {n : R} (h : IsUnit n) : ¬IsPrimePow n | fun h' => h'.not_unit h | theorem | IsUnit.not_isPrimePow | Algebra | Mathlib/Algebra/IsPrimePow.lean | [] | [
"IsPrimePow",
"IsUnit"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
not_isPrimePow_one : ¬IsPrimePow (1 : R) | isUnit_one.not_isPrimePow | theorem | not_isPrimePow_one | Algebra | Mathlib/Algebra/IsPrimePow.lean | [] | [
"IsPrimePow"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.