fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
Submonoid.FG.map_injective {M' : Type*} [Monoid M'] {P : Submonoid M} (e : M →* M')
(he : Function.Injective e) (h : (P.map e).FG) : P.FG := by
obtain ⟨s, hs⟩ := h
use s.preimage e he.injOn
apply Submonoid.map_injective_of_injective he
rw [← hs, MonoidHom.map_mclosure e, Finset.coe_preimage]
congr
rw [Set.image_preimage_eq_iff, ← MonoidHom.coe_mrange e, ← Submonoid.closure_le, hs,
MonoidHom.mrange_eq_map e]
exact Submonoid.monotone_map le_top
@[to_additive (attr := simp)] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Submonoid.FG.map_injective | null |
Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.FG N ↔ N.FG := by
conv_rhs => rw [← N.mrange_subtype, MonoidHom.mrange_eq_map]
exact ⟨fun h ↦ h.fg_top.map N.subtype, fun h => ⟨h.map_injective N.subtype Subtype.coe_injective⟩⟩
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Monoid.fg_iff_submonoid_fg | null |
Monoid.fg_of_surjective {M' : Type*} [Monoid M'] [Monoid.FG M] (f : M →* M')
(hf : Function.Surjective f) : Monoid.FG M' := by
classical
obtain ⟨s, hs⟩ := Monoid.fg_def.mp ‹_›
use s.image f
rwa [Finset.coe_image, ← MonoidHom.map_mclosure, hs, ← MonoidHom.mrange_eq_map,
MonoidHom.mrange_eq_top]
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Monoid.fg_of_surjective | null |
Monoid.fg_range {M' : Type*} [Monoid M'] [Monoid.FG M] (f : M →* M') :
Monoid.FG (MonoidHom.mrange f) :=
Monoid.fg_of_surjective f.mrangeRestrict f.mrangeRestrict_surjective
@[to_additive] | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Monoid.fg_range | null |
Submonoid.powers_fg (r : M) : (Submonoid.powers r).FG :=
⟨{r}, (Finset.coe_singleton r).symm ▸ (Submonoid.powers_eq_closure r).symm⟩
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Submonoid.powers_fg | null |
Monoid.powers_fg (r : M) : Monoid.FG (Submonoid.powers r) :=
(Monoid.fg_iff_submonoid_fg _).mpr (Submonoid.powers_fg r)
@[to_additive] | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Monoid.powers_fg | null |
Monoid.closure_finset_fg (s : Finset M) : Monoid.FG (Submonoid.closure (s : Set M)) := by
refine ⟨⟨s.preimage Subtype.val Subtype.coe_injective.injOn, ?_⟩⟩
rw [Finset.coe_preimage, Submonoid.closure_closure_coe_preimage]
@[to_additive] | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Monoid.closure_finset_fg | null |
Monoid.closure_finite_fg (s : Set M) [Finite s] : Monoid.FG (Submonoid.closure s) :=
haveI := Fintype.ofFinite s
s.coe_toFinset ▸ Monoid.closure_finset_fg s.toFinset
/-! ### Groups and subgroups -/
variable {G H : Type*} [Group G] [AddGroup H] | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Monoid.closure_finite_fg | null |
@[to_additive]
Subgroup.FG (P : Subgroup G) : Prop :=
∃ S : Finset G, Subgroup.closure ↑S = P | def | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Subgroup.FG | A subgroup of `G` is finitely generated if it is the closure of a finite subset of `G`. |
@[to_additive /-- An equivalent expression of `AddSubgroup.fg` in terms of `Set.Finite` instead of
`Finset`. -/]
Subgroup.fg_iff (P : Subgroup G) :
Subgroup.FG P ↔ ∃ S : Set G, Subgroup.closure S = P ∧ S.Finite :=
⟨fun ⟨S, hS⟩ => ⟨S, hS, Finset.finite_toSet S⟩, fun ⟨S, hS, hf⟩ =>
⟨Set.Finite.toFinset hf, by simp [hS]⟩⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Subgroup.fg_iff | An additive subgroup of `H` is finitely generated if it is the closure of a finite subset of
`H`. -/
add_decl_doc AddSubgroup.FG
/-- An equivalent expression of `Subgroup.FG` in terms of `Set.Finite` instead of `Finset`. |
@[to_additive /-- An additive subgroup is finitely generated if
and only if it is finitely generated as an additive submonoid. -/]
Subgroup.fg_iff_submonoid_fg (P : Subgroup G) : P.FG ↔ P.toSubmonoid.FG := by
constructor
· rintro ⟨S, rfl⟩
rw [Submonoid.fg_iff]
refine ⟨S ∪ S⁻¹, ?_, S.finite_toSet.union S.finite_toSet.inv⟩
exact (Subgroup.closure_toSubmonoid _).symm
· rintro ⟨S, hS⟩
refine ⟨S, le_antisymm ?_ ?_⟩
· rw [Subgroup.closure_le, ← Subgroup.coe_toSubmonoid, ← hS]
exact Submonoid.subset_closure
· rw [← Subgroup.toSubmonoid_le, ← hS, Submonoid.closure_le]
exact Subgroup.subset_closure | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Subgroup.fg_iff_submonoid_fg | A subgroup is finitely generated if and only if it is finitely generated as a submonoid. |
Subgroup.fg_iff_add_fg (P : Subgroup G) : P.FG ↔ P.toAddSubgroup.FG := by
rw [Subgroup.fg_iff_submonoid_fg, AddSubgroup.fg_iff_addSubmonoid_fg]
exact (Subgroup.toSubmonoid P).fg_iff_add_fg | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Subgroup.fg_iff_add_fg | null |
AddSubgroup.fg_iff_mul_fg (P : AddSubgroup H) : P.FG ↔ P.toSubgroup.FG := by
rw [AddSubgroup.fg_iff_addSubmonoid_fg, Subgroup.fg_iff_submonoid_fg]
exact AddSubmonoid.fg_iff_mul_fg (AddSubgroup.toAddSubmonoid P)
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | AddSubgroup.fg_iff_mul_fg | null |
Subgroup.FG.bot : FG (⊥ : Subgroup G) :=
⟨∅, by simp⟩
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Subgroup.FG.bot | null |
Subgroup.FG.sup {P Q : Subgroup G} (hP : P.FG) (hQ : Q.FG) : (P ⊔ Q).FG := by
classical
rcases hP with ⟨s, rfl⟩
rcases hQ with ⟨t, rfl⟩
exact ⟨s ∪ t, by simp [closure_union]⟩
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Subgroup.FG.sup | null |
Subgroup.FG.finset_sup {ι : Type*} (s : Finset ι) (P : ι → Subgroup G)
(hP : ∀ i ∈ s, (P i).FG) : (s.sup P).FG :=
Finset.sup_induction bot (fun _ ha _ hb => ha.sup hb) hP
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Subgroup.FG.finset_sup | null |
Subgroup.FG.biSup_finset {ι : Type*} (s : Finset ι) (P : ι → Subgroup G)
(hP : ∀ i ∈ s, (P i).FG) : (⨆ i ∈ s, P i).FG := by
simpa only [Finset.sup_eq_iSup] using finset_sup s P hP
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Subgroup.FG.biSup_finset | null |
Subgroup.FG.biSup {ι : Type*} {s : Set ι} (hs : s.Finite) (P : ι → Subgroup G)
(hP : ∀ i ∈ s, (P i).FG) : (⨆ i ∈ s, P i).FG := by
simpa using biSup_finset hs.toFinset P (by simpa)
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Subgroup.FG.biSup | null |
Subgroup.FG.iSup {ι : Sort*} [Finite ι] (P : ι → Subgroup G) (hP : ∀ i, (P i).FG) :
(iSup P).FG := by
simpa [iSup_plift_down] using biSup Set.finite_univ (P ∘ PLift.down) fun i _ => hP i.down | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Subgroup.FG.iSup | null |
@[to_additive prod
/-- The product of two finitely generated additive subgroups is finitely generated. -/]
Subgroup.FG.prod {G' : Type*} [Group G'] {P : Subgroup G} {Q : Subgroup G'}
(hP : P.FG) (hQ : Q.FG) : (P.prod Q).FG := by
rw [fg_iff_submonoid_fg] at *
exact hP.prod hQ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Subgroup.FG.prod | The product of two finitely generated subgroups is finitely generated. |
@[to_additive /-- Finite product of finitely generated additive subgroups is finitely generated. -/]
Subgroup.FG.pi {ι : Type*} [Finite ι] {G : ι → Type*} [∀ i, Group (G i)]
{P : ∀ i, Subgroup (G i)} (hP : ∀ i, (P i).FG) : (pi Set.univ P).FG := by
simp_rw [fg_iff_submonoid_fg] at *
exact .pi hP | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Subgroup.FG.pi | Finite product of finitely generated subgroups is finitely generated. |
Group.FG : Prop where
out : (⊤ : Subgroup G).FG | class | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Group.FG | A group is finitely generated if it is finitely generated as a subgroup of itself. |
AddGroup.FG : Prop where
out : (⊤ : AddSubgroup H).FG
attribute [to_additive] Group.FG
variable {G H} | class | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | AddGroup.FG | An additive group is finitely generated if it is finitely generated as an additive subgroup of
itself. |
Group.fg_def : Group.FG G ↔ (⊤ : Subgroup G).FG :=
⟨fun h => h.1, fun h => ⟨h⟩⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Group.fg_def | null |
AddGroup.fg_def : AddGroup.FG H ↔ (⊤ : AddSubgroup H).FG :=
⟨fun h => h.1, fun h => ⟨h⟩⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | AddGroup.fg_def | null |
@[to_additive
/-- An equivalent expression of `AddGroup.fg` in terms of `Set.Finite` instead of `Finset`. -/]
Group.fg_iff : Group.FG G ↔ ∃ S : Set G, Subgroup.closure S = (⊤ : Subgroup G) ∧ S.Finite :=
⟨fun h => (Subgroup.fg_iff ⊤).1 h.out, fun h => ⟨(Subgroup.fg_iff ⊤).2 h⟩⟩
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Group.fg_iff | An equivalent expression of `Group.FG` in terms of `Set.Finite` instead of `Finset`. |
Group.fg_iff' :
Group.FG G ↔ ∃ (n : _) (S : Finset G), S.card = n ∧ Subgroup.closure (S : Set G) = ⊤ :=
Group.fg_def.trans ⟨fun ⟨S, hS⟩ => ⟨S.card, S, rfl, hS⟩, fun ⟨_n, S, _hn, hS⟩ => ⟨S, hS⟩⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Group.fg_iff' | null |
@[to_additive /-- An additive group is finitely generated if and only
if it is finitely generated as an additive monoid. -/]
Group.fg_iff_monoid_fg : Group.FG G ↔ Monoid.FG G :=
⟨fun h => Monoid.fg_def.2 <| (Subgroup.fg_iff_submonoid_fg ⊤).1 (Group.fg_def.1 h), fun h =>
Group.fg_def.2 <| (Subgroup.fg_iff_submonoid_fg ⊤).2 (Monoid.fg_def.1 h)⟩
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Group.fg_iff_monoid_fg | A group is finitely generated if and only if it is finitely generated as a monoid. |
Monoid.fg_of_group_fg [Group.FG G] : Monoid.FG G :=
Group.fg_iff_monoid_fg.1 ‹_›
@[to_additive (attr := simp)] | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Monoid.fg_of_group_fg | null |
Group.fg_iff_subgroup_fg (H : Subgroup G) : Group.FG H ↔ H.FG :=
(fg_iff_monoid_fg.trans (Monoid.fg_iff_submonoid_fg _)).trans
(Subgroup.fg_iff_submonoid_fg _).symm | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Group.fg_iff_subgroup_fg | null |
GroupFG.iff_add_fg : Group.FG G ↔ AddGroup.FG (Additive G) :=
⟨fun h => ⟨(Subgroup.fg_iff_add_fg ⊤).1 h.out⟩, fun h => ⟨(Subgroup.fg_iff_add_fg ⊤).2 h.out⟩⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | GroupFG.iff_add_fg | null |
AddGroup.fg_iff_mul_fg : AddGroup.FG H ↔ Group.FG (Multiplicative H) :=
⟨fun h => ⟨(AddSubgroup.fg_iff_mul_fg ⊤).1 h.out⟩, fun h =>
⟨(AddSubgroup.fg_iff_mul_fg ⊤).2 h.out⟩⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | AddGroup.fg_iff_mul_fg | null |
AddGroup.fg_of_group_fg [Group.FG G] : AddGroup.FG (Additive G) :=
GroupFG.iff_add_fg.1 ‹_› | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | AddGroup.fg_of_group_fg | null |
Group.fg_of_mul_group_fg [AddGroup.FG H] : Group.FG (Multiplicative H) :=
AddGroup.fg_iff_mul_fg.1 ‹_›
@[to_additive] | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Group.fg_of_mul_group_fg | null |
@[to_additive]
Group.fg_of_surjective {G' : Type*} [Group G'] [hG : Group.FG G] {f : G →* G'}
(hf : Function.Surjective f) : Group.FG G' :=
Group.fg_iff_monoid_fg.mpr <|
@Monoid.fg_of_surjective G _ G' _ (Group.fg_iff_monoid_fg.mp hG) f hf
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Group.fg_of_surjective | null |
Group.fg_range {G' : Type*} [Group G'] [Group.FG G] (f : G →* G') : Group.FG f.range :=
Group.fg_of_surjective f.rangeRestrict_surjective
@[to_additive] | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Group.fg_range | null |
Group.closure_finset_fg (s : Finset G) : Group.FG (Subgroup.closure (s : Set G)) := by
refine ⟨⟨s.preimage Subtype.val Subtype.coe_injective.injOn, ?_⟩⟩
rw [Finset.coe_preimage, ← Subgroup.coe_subtype, Subgroup.closure_preimage_eq_top]
@[to_additive] | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Group.closure_finset_fg | null |
Group.closure_finite_fg (s : Set G) [Finite s] : Group.FG (Subgroup.closure s) :=
haveI := Fintype.ofFinite s
s.coe_toFinset ▸ Group.closure_finset_fg s.toFinset | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Group.closure_finite_fg | null |
@[to_additive]
QuotientGroup.fg [Group.FG G] (N : Subgroup G) [Subgroup.Normal N] : Group.FG <| G ⧸ N :=
Group.fg_of_surjective <| QuotientGroup.mk'_surjective N | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | QuotientGroup.fg | null |
@[to_additive /-- The product of two finitely generated additive monoids is finitely generated. -/]
instMonoidFG [FG M] [FG N] : FG (M × N) where
fg_top := by
rw [← Submonoid.top_prod_top]
exact ‹FG M›.fg_top.prod ‹FG N›.fg_top
open Group in | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | instMonoidFG | The product of two finitely generated monoids is finitely generated. |
@[to_additive /-- The product of two finitely generated additive groups is finitely generated. -/]
instGroupFG [FG G] [FG G'] : FG (G × G') where
out := by
rw [← Subgroup.top_prod_top]
exact ‹FG G›.out.prod ‹FG G'›.out | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | instGroupFG | The product of two finitely generated groups is finitely generated. |
@[to_additive /-- Finite product of finitely generated additive monoids is finitely generated. -/]
instMonoidFG {M : ι → Type*} [∀ i, Monoid (M i)] [∀ i, Monoid.FG (M i)] :
Monoid.FG (∀ i, M i) where
fg_top := by
rw [← Submonoid.pi_top Set.univ]
exact .pi fun i => Monoid.FG.fg_top | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | instMonoidFG | Finite product of finitely generated monoids is finitely generated. |
@[to_additive /-- Finite product of finitely generated additive groups is finitely generated. -/]
instGroupFG {G : ι → Type*} [∀ i, Group (G i)] [∀ i, Group.FG (G i)] :
Group.FG (∀ i, G i) where
out := by
rw [← Subgroup.pi_top Set.univ]
exact .pi fun i => Group.FG.out | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | instGroupFG | Finite product of finitely generated groups is finitely generated. |
FixedPointFree [One G] := ∀ g, φ g = g → g = 1 | def | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type"
] | Mathlib/GroupTheory/FixedPointFree.lean | FixedPointFree | A function `φ : G → G` is fixed-point-free if `1 : G` is the only fixed point of `φ`. |
commutatorMap [Div G] (g : G) := g / φ g
@[simp] theorem commutatorMap_apply [Div G] (g : G) : commutatorMap φ g = g / φ g := rfl | def | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type"
] | Mathlib/GroupTheory/FixedPointFree.lean | commutatorMap | The commutator map `g ↦ g / φ g`. If `φ g = h * g * h⁻¹`, then `g / φ g` is exactly the
commutator `[g, h] = g * h * g⁻¹ * h⁻¹`. |
commutatorMap_injective (hφ : FixedPointFree φ) : Function.Injective (commutatorMap φ) := by
refine fun x y h ↦ inv_mul_eq_one.mp <| hφ _ ?_
rwa [map_mul, map_inv, eq_inv_mul_iff_mul_eq, ← mul_assoc, ← eq_div_iff_mul_eq', ← division_def]
variable [Finite G] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type"
] | Mathlib/GroupTheory/FixedPointFree.lean | commutatorMap_injective | null |
commutatorMap_surjective (hφ : FixedPointFree φ) : Function.Surjective (commutatorMap φ) :=
Finite.surjective_of_injective hφ.commutatorMap_injective | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type"
] | Mathlib/GroupTheory/FixedPointFree.lean | commutatorMap_surjective | null |
prod_pow_eq_one (hφ : FixedPointFree φ) {n : ℕ} (hn : φ^[n] = _root_.id) (g : G) :
((List.range n).map (fun k ↦ φ^[k] g)).prod = 1 := by
obtain ⟨g, rfl⟩ := commutatorMap_surjective hφ g
simp only [commutatorMap_apply, iterate_map_div, ← Function.iterate_succ_apply]
rw [List.prod_range_div', Function.iterate_zero_apply, hn, Function.id_def, div_self'] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type"
] | Mathlib/GroupTheory/FixedPointFree.lean | prod_pow_eq_one | null |
coe_eq_inv_of_sq_eq_one (hφ : FixedPointFree φ) (h2 : φ^[2] = _root_.id) : ⇑φ = (·⁻¹) := by
ext g
have key : g * φ g = 1 := by simpa [List.range_succ] using hφ.prod_pow_eq_one h2 g
rwa [← inv_eq_iff_mul_eq_one, eq_comm] at key | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type"
] | Mathlib/GroupTheory/FixedPointFree.lean | coe_eq_inv_of_sq_eq_one | null |
coe_eq_inv_of_involutive (hφ : FixedPointFree φ) (h2 : Function.Involutive φ) :
⇑φ = (·⁻¹) :=
coe_eq_inv_of_sq_eq_one hφ (funext h2) | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type"
] | Mathlib/GroupTheory/FixedPointFree.lean | coe_eq_inv_of_involutive | null |
commute_all_of_involutive (hφ : FixedPointFree φ) (h2 : Function.Involutive φ) (g h : G) :
Commute g h := by
have key := map_mul φ g h
rwa [hφ.coe_eq_inv_of_involutive h2, inv_eq_iff_eq_inv, mul_inv_rev, inv_inv, inv_inv] at key | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type"
] | Mathlib/GroupTheory/FixedPointFree.lean | commute_all_of_involutive | null |
commGroupOfInvolutive (hφ : FixedPointFree φ) (h2 : Function.Involutive φ) :
CommGroup G := .mk (hφ.commute_all_of_involutive h2) | def | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type"
] | Mathlib/GroupTheory/FixedPointFree.lean | commGroupOfInvolutive | If a finite group admits a fixed-point-free involution, then it is commutative. |
orderOf_ne_two_of_involutive (hφ : FixedPointFree φ) (h2 : Function.Involutive φ) (g : G) :
orderOf g ≠ 2 := by
intro hg
have key : φ g = g := by
rw [hφ.coe_eq_inv_of_involutive h2, inv_eq_iff_mul_eq_one, ← sq, ← hg, pow_orderOf_eq_one]
rw [hφ g key, orderOf_one] at hg
contradiction | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type"
] | Mathlib/GroupTheory/FixedPointFree.lean | orderOf_ne_two_of_involutive | null |
odd_card_of_involutive (hφ : FixedPointFree φ) (h2 : Function.Involutive φ) :
Odd (Nat.card G) := by
have := Fintype.ofFinite G
by_contra h
rw [Nat.not_odd_iff_even, even_iff_two_dvd, Nat.card_eq_fintype_card] at h
obtain ⟨g, hg⟩ := exists_prime_orderOf_dvd_card 2 h
exact hφ.orderOf_ne_two_of_involutive h2 g hg | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type"
] | Mathlib/GroupTheory/FixedPointFree.lean | odd_card_of_involutive | null |
odd_orderOf_of_involutive (hφ : FixedPointFree φ) (h2 : Function.Involutive φ) (g : G) :
Odd (orderOf g) :=
Odd.of_dvd_nat (hφ.odd_card_of_involutive h2) (orderOf_dvd_natCard g) | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type"
] | Mathlib/GroupTheory/FixedPointFree.lean | odd_orderOf_of_involutive | null |
frattini (G : Type*) [Group G] : Subgroup G :=
Order.radical (Subgroup G)
variable {G H : Type*} [Group G] [Group H] {φ : G →* H} | def | GroupTheory | [
"Mathlib.GroupTheory.Nilpotent",
"Mathlib.Order.Radical"
] | Mathlib/GroupTheory/Frattini.lean | frattini | The Frattini subgroup of a group is the intersection of the maximal subgroups. |
frattini_le_coatom {K : Subgroup G} (h : IsCoatom K) : frattini G ≤ K :=
Order.radical_le_coatom h
open Subgroup | lemma | GroupTheory | [
"Mathlib.GroupTheory.Nilpotent",
"Mathlib.Order.Radical"
] | Mathlib/GroupTheory/Frattini.lean | frattini_le_coatom | null |
frattini_le_comap_frattini_of_surjective (hφ : Function.Surjective φ) :
frattini G ≤ (frattini H).comap φ := by
simp_rw [frattini, Order.radical, comap_iInf, le_iInf_iff]
intro M hM
apply biInf_le
exact isCoatom_comap_of_surjective hφ hM | lemma | GroupTheory | [
"Mathlib.GroupTheory.Nilpotent",
"Mathlib.Order.Radical"
] | Mathlib/GroupTheory/Frattini.lean | frattini_le_comap_frattini_of_surjective | null |
frattini_characteristic : (frattini G).Characteristic := by
rw [characteristic_iff_comap_eq]
intro φ
apply φ.comapSubgroup.map_radical | instance | GroupTheory | [
"Mathlib.GroupTheory.Nilpotent",
"Mathlib.Order.Radical"
] | Mathlib/GroupTheory/Frattini.lean | frattini_characteristic | The Frattini subgroup is characteristic. |
frattini_nongenerating [IsCoatomic (Subgroup G)] {K : Subgroup G}
(h : K ⊔ frattini G = ⊤) : K = ⊤ :=
Order.radical_nongenerating h | theorem | GroupTheory | [
"Mathlib.GroupTheory.Nilpotent",
"Mathlib.Order.Radical"
] | Mathlib/GroupTheory/Frattini.lean | frattini_nongenerating | The Frattini subgroup consists of "non-generating" elements in the following sense:
If a subgroup together with the Frattini subgroup generates the whole group,
then the subgroup is already the whole group. |
frattini_nilpotent [Finite G] : Group.IsNilpotent (frattini G) := by
have q := (isNilpotent_of_finite_tfae (G := frattini G)).out 0 3
rw [q]; clear q
intro p p_prime P
have frattini_argument := Sylow.normalizer_sup_eq_top P
have normalizer_P := frattini_nongenerating frattini_argument
have P_normal_in_G : (map (frattini G).subtype P).Normal := normalizer_eq_top_iff.mp normalizer_P
exact P_normal_in_G.of_map_subtype | theorem | GroupTheory | [
"Mathlib.GroupTheory.Nilpotent",
"Mathlib.Order.Radical"
] | Mathlib/GroupTheory/Frattini.lean | frattini_nilpotent | When `G` is finite, the Frattini subgroup is nilpotent. |
FreeAbelianGroup : Type u :=
Additive <| Abelianization <| FreeGroup α | def | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | FreeAbelianGroup | If `α` is a type, then `FreeAbelianGroup α` is the free abelian group generated by `α`.
This is an abelian group equipped with a function
`FreeAbelianGroup.of : α → FreeAbelianGroup α` which has the following universal property:
if `G` is any abelian group, and `f : α → G` is any function, then this function is
the composite of `FreeAbelianGroup.of` and a unique group homomorphism
`FreeAbelianGroup.lift f : FreeAbelianGroup α →+ G`.
A typical element of `FreeAbelianGroup α` is a formal sum of
elements of `α` and their formal inverses.
For example if `x` and `y` are terms of type `α` then `x + x + x - y` is a
"typical" element of `FreeAbelianGroup α`. In particular if `α` is empty
then `FreeAbelianGroup α` is isomorphic to the trivial group, and if `α` has one term
then `FreeAbelianGroup α` is isomorphic to `ℤ`.
One can think of `FreeAbelianGroup α` as the functions `α →₀ ℤ` with finite support,
and addition given pointwise.
TODO: rename to `FreeAddCommGroup` and introduce a multiplicative version |
FreeAbelianGroup.addCommGroup : AddCommGroup (FreeAbelianGroup α) :=
@Additive.addCommGroup _ <| Abelianization.commGroup _ | instance | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | FreeAbelianGroup.addCommGroup | null |
of (x : α) : FreeAbelianGroup α :=
Additive.ofMul <| Abelianization.of <| FreeGroup.of x | def | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | of | The canonical map from `α` to `FreeAbelianGroup α`. |
lift {β : Type v} [AddCommGroup β] : (α → β) ≃ (FreeAbelianGroup α →+ β) :=
(@FreeGroup.lift _ (Multiplicative β) _).trans <|
(@Abelianization.lift _ _ (Multiplicative β) _).trans MonoidHom.toAdditive | def | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | lift | The map `FreeAbelianGroup α →+ A` induced by a map of types `α → A`. |
@[simp]
lift_apply_of (x : α) : lift f (of x) = f x := by
convert Abelianization.lift_apply_of
(FreeGroup.lift f (β := Multiplicative β)) (FreeGroup.of x)
exact (FreeGroup.lift_apply_of (β := Multiplicative β)).symm
@[deprecated (since := "2025-07-23")] protected alias lift.of := lift_apply_of | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | lift_apply_of | null |
lift_unique (g : FreeAbelianGroup α →+ β) (hg : ∀ x, g (of x) = f x) {x} :
g x = lift f x :=
DFunLike.congr_fun (lift.symm_apply_eq.mp (funext hg : g ∘ of = f)) _
@[deprecated (since := "2025-07-23")] protected alias lift.unique := lift_unique | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | lift_unique | null |
@[ext high]
lift_ext (g h : FreeAbelianGroup α →+ β) (H : ∀ x, g (of x) = h (of x)) : g = h :=
lift.symm.injective <| funext H
@[deprecated (since := "2025-07-23")] protected alias lift.ext := lift_ext | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | lift_ext | See note [partially-applied ext lemmas]. |
lift_comp_apply {α β γ} [AddCommGroup β] [AddCommGroup γ]
(a : FreeAbelianGroup α) (f : α → β) (g : β →+ γ) : lift (g ∘ f) a = g (lift f a) := by
rw [← AddMonoidHom.comp_apply g (lift f)]
refine (lift_unique _ _ ?_).symm
intro a
change g ((lift f) (of a)) = g (f a)
simp only [lift_apply_of]
@[deprecated lift_comp_apply (since := "2025-07-23")] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | lift_comp_apply | null |
lift.map_hom {α β γ} [AddCommGroup β] [AddCommGroup γ] (a : FreeAbelianGroup α) (f : α → β)
(g : β →+ γ) : g (lift f a) = lift (g ∘ f) a :=
(lift_comp_apply a f g).symm | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | lift.map_hom | null |
of_injective : Function.Injective (of : α → FreeAbelianGroup α) :=
fun x y hoxy ↦ Classical.by_contradiction fun hxy : x ≠ y ↦
let f : FreeAbelianGroup α →+ ℤ := lift fun z ↦ if x = z then (1 : ℤ) else 0
have hfx1 : f (of x) = 1 := (lift_apply_of _ _).trans <| if_pos rfl
have hfy1 : f (of y) = 1 := hoxy ▸ hfx1
have hfy0 : f (of y) = 0 := (lift_apply_of _ _).trans <| if_neg hxy
one_ne_zero <| hfy1.symm.trans hfy0
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | of_injective | null |
of_ne_zero (x : α) : of x ≠ 0 := by
intro h
let f : FreeAbelianGroup α →+ ℤ := lift 1
have hfx : f (of x) = 1 := lift_apply_of _ _
have hf0 : f (of x) = 0 := by rw [h, map_zero]
exact one_ne_zero <| hfx.symm.trans hf0
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | of_ne_zero | null |
zero_ne_of (x : α) : 0 ≠ of x := of_ne_zero _ |>.symm | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | zero_ne_of | null |
@[elab_as_elim]
protected induction_on {C : FreeAbelianGroup α → Prop} (z : FreeAbelianGroup α) (C0 : C 0)
(C1 : ∀ x, C <| of x) (Cn : ∀ x, C (of x) → C (-of x)) (Cp : ∀ x y, C x → C y → C (x + y)) :
C z :=
Quotient.inductionOn' z fun x ↦
Quot.inductionOn x fun L ↦
List.recOn L C0 fun ⟨x, b⟩ _ ih ↦ Bool.recOn b (Cp _ _ (Cn _ (C1 x)) ih) (Cp _ _ (C1 x) ih) | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | induction_on | null |
lift_add_apply [AddCommGroup G] (f g : α → G) (a : FreeAbelianGroup α) :
lift (f + g) a = lift f a + lift g a := by
refine FreeAbelianGroup.induction_on a ?_ ?_ ?_ ?_
· simp only [(lift _).map_zero, zero_add]
· intro x
simp only [lift_apply_of, Pi.add_apply]
· intro x _
simp only [map_neg, lift_apply_of, Pi.add_apply, neg_add]
· intro x y hx hy
simp only [(lift _).map_add, hx, hy, add_add_add_comm]
@[deprecated (since := "2025-07-13")] alias lift.add' := lift_add_apply
@[simp] lemma lift_add [AddCommGroup G] (f g : α → G) : lift (f + g) = lift f + lift g :=
AddMonoidHom.ext <| lift_add_apply _ _ | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | lift_add_apply | null |
@[simps!]
liftAddEquiv [AddCommGroup G] : (α → G) ≃+ (FreeAbelianGroup α →+ G) := ⟨lift, lift_add⟩ | def | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | liftAddEquiv | `FreeAbelianGroup.lift` as an equivalence of groups. |
@[simps!]
liftAddGroupHom {α} (β) [AddCommGroup β] (a : FreeAbelianGroup α) : (α → β) →+ β :=
AddMonoidHom.mk' (fun f ↦ lift f a) (lift_add_apply · · _)
@[simp] lemma lift_neg [AddCommGroup G] (f : α → G) : lift (-f) = -lift f := liftAddEquiv.map_neg f | def | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | liftAddGroupHom | If `g : FreeAbelianGroup X` and `A` is an abelian group then `liftAddGroupHom g`
is the additive group homomorphism sending a function `X → A` to the term of type `A`
corresponding to the evaluation of the induced map `FreeAbelianGroup X → A` at `g`. |
lift_neg_apply [AddCommGroup G] (f : α → G) (a : FreeAbelianGroup α) :
lift (-f) a = -lift f a := congr($(lift_neg f) a)
@[deprecated (since := "2025-07-13")] alias lift_neg' := lift_neg | lemma | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | lift_neg_apply | null |
@[elab_as_elim]
protected induction_on' {C : FreeAbelianGroup α → Prop} (z : FreeAbelianGroup α) (C0 : C 0)
(C1 : ∀ x, C <| pure x) (Cn : ∀ x, C (pure x) → C (-pure x))
(Cp : ∀ x y, C x → C y → C (x + y)) : C z :=
FreeAbelianGroup.induction_on z C0 C1 Cn Cp
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | induction_on' | null |
map_pure (f : α → β) (x : α) : f <$> (pure x : FreeAbelianGroup α) = pure (f x) :=
rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | map_pure | null |
protected map_zero (f : α → β) : f <$> (0 : FreeAbelianGroup α) = 0 :=
(lift (of ∘ f)).map_zero
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | map_zero | null |
protected map_add (f : α → β) (x y : FreeAbelianGroup α) :
f <$> (x + y) = f <$> x + f <$> y :=
(lift _).map_add _ _
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | map_add | null |
protected map_neg (f : α → β) (x : FreeAbelianGroup α) : f <$> (-x) = -f <$> x :=
map_neg (lift <| of ∘ f) _
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | map_neg | null |
protected map_sub (f : α → β) (x y : FreeAbelianGroup α) :
f <$> (x - y) = f <$> x - f <$> y :=
map_sub (lift <| of ∘ f) _ _
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | map_sub | null |
map_of (f : α → β) (y : α) : f <$> of y = of (f y) :=
rfl | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | map_of | null |
pure_bind (f : α → FreeAbelianGroup β) (x) : pure x >>= f = f x :=
lift_apply_of _ _
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | pure_bind | null |
zero_bind (f : α → FreeAbelianGroup β) : 0 >>= f = 0 :=
(lift f).map_zero
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | zero_bind | null |
add_bind (f : α → FreeAbelianGroup β) (x y : FreeAbelianGroup α) :
x + y >>= f = (x >>= f) + (y >>= f) :=
(lift _).map_add _ _
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | add_bind | null |
neg_bind (f : α → FreeAbelianGroup β) (x : FreeAbelianGroup α) : -x >>= f = -(x >>= f) :=
map_neg (lift f) _
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | neg_bind | null |
sub_bind (f : α → FreeAbelianGroup β) (x y : FreeAbelianGroup α) :
x - y >>= f = (x >>= f) - (y >>= f) :=
map_sub (lift f) _ _
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | sub_bind | null |
pure_seq (f : α → β) (x : FreeAbelianGroup α) : pure f <*> x = f <$> x :=
pure_bind _ _
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | pure_seq | null |
zero_seq (x : FreeAbelianGroup α) : (0 : FreeAbelianGroup (α → β)) <*> x = 0 :=
zero_bind _
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | zero_seq | null |
add_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
f + g <*> x = (f <*> x) + (g <*> x) :=
add_bind _ _ _
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | add_seq | null |
neg_seq (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : -f <*> x = -(f <*> x) :=
neg_bind _ _
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | neg_seq | null |
sub_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
f - g <*> x = (f <*> x) - (g <*> x) :=
sub_bind _ _ _ | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | sub_seq | null |
seqAddGroupHom (f : FreeAbelianGroup (α → β)) : FreeAbelianGroup α →+ FreeAbelianGroup β := by
refine .mk' (f <*> ·) fun x y ↦ ?_
change lift (· <$> (x + y)) _ = lift (· <$> x) _ + lift (· <$> y) _
simp [← Pi.add_def]
@[simp] | def | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | seqAddGroupHom | If `f : FreeAbelianGroup (α → β)`, then `f <*>` is an additive morphism
`FreeAbelianGroup α →+ FreeAbelianGroup β`. |
seq_zero (f : FreeAbelianGroup (α → β)) : f <*> 0 = 0 :=
(seqAddGroupHom f).map_zero
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | seq_zero | null |
seq_add (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
f <*> x + y = (f <*> x) + (f <*> y) :=
(seqAddGroupHom f).map_add x y
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | seq_add | null |
seq_neg (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : f <*> -x = -(f <*> x) :=
(seqAddGroupHom f).map_neg x
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | seq_neg | null |
seq_sub (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
f <*> x - y = (f <*> x) - (f <*> y) :=
(seqAddGroupHom f).map_sub x y | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | seq_sub | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.