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 ⌀ |
|---|---|---|---|---|---|---|
LinearOrderedAddCommGroup.wellFoundedOn_setOf_le_lt_iff_nonempty_discrete
{G : Type*} [AddCommGroup G] [LinearOrder G] [IsOrderedAddMonoid G] [Nontrivial G] {g : G} :
Set.WellFoundedOn {x : G | g ≤ x} (· < ·) ↔ Nonempty (G ≃+o ℤ) := by
suffices Set.WellFoundedOn {x : G | 0 ≤ x} (· < ·) ↔ Nonempty (G ≃+o ℤ) by... | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | LinearOrderedAddCommGroup.wellFoundedOn_setOf_le_lt_iff_nonempty_discrete | null |
LinearOrderedAddCommGroup.wellFoundedOn_setOf_ge_gt_iff_nonempty_discrete
{G : Type*} [AddCommGroup G] [LinearOrder G] [IsOrderedAddMonoid G] [Nontrivial G] (g : G) :
Set.WellFoundedOn {x : G | x ≤ g} (· > ·) ↔ Nonempty (G ≃+o ℤ) := by
rw [← wellFoundedOn_setOf_le_lt_iff_nonempty_discrete (g := -g)]
refine ... | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | LinearOrderedAddCommGroup.wellFoundedOn_setOf_ge_gt_iff_nonempty_discrete | null |
LinearOrderedCommGroup.wellFoundedOn_setOf_le_lt_iff_nonempty_discrete
{G : Type*} [CommGroup G] [LinearOrder G] [IsOrderedMonoid G] [Nontrivial G] {g : G} :
Set.WellFoundedOn {x : G | g ≤ x} (· < ·) ↔ Nonempty (G ≃*o Multiplicative ℤ) := by
let e : G ≃o Additive G := OrderIso.refl G
suffices Set.WellFounde... | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | LinearOrderedCommGroup.wellFoundedOn_setOf_le_lt_iff_nonempty_discrete | null |
LinearOrderedCommGroup.wellFoundedOn_setOf_ge_gt_iff_nonempty_discrete
{G : Type*} [CommGroup G] [LinearOrder G] [IsOrderedMonoid G] [Nontrivial G] (g : G) :
Set.WellFoundedOn {x : G | x ≤ g} (· > ·) ↔ Nonempty (G ≃*o Multiplicative ℤ) := by
rw [← wellFoundedOn_setOf_le_lt_iff_nonempty_discrete (g := g⁻¹)]
... | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | LinearOrderedCommGroup.wellFoundedOn_setOf_ge_gt_iff_nonempty_discrete | null |
LinearOrderedCommGroupWithZero.wellFoundedOn_setOf_le_lt_iff_nonempty_discrete_of_ne_zero
{G₀ : Type*} [LinearOrderedCommGroupWithZero G₀] [Nontrivial G₀ˣ] {g : G₀} (hg : g ≠ 0) :
Set.WellFoundedOn {x : G₀ | g ≤ x} (· < ·) ↔ Nonempty (G₀ ≃*o ℤᵐ⁰) := by
suffices Set.WellFoundedOn {x : G₀ | g ≤ x} (· < ·) ↔
... | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | LinearOrderedCommGroupWithZero.wellFoundedOn_setOf_le_lt_iff_nonempty_discrete_of_ne_zero | null |
LinearOrderedCommGroupWithZero.wellFoundedOn_setOf_ge_gt_iff_nonempty_discrete_of_ne_zero
{G₀ : Type*} [LinearOrderedCommGroupWithZero G₀] [Nontrivial G₀ˣ] {g : G₀} (hg : g ≠ 0) :
Set.WellFoundedOn {x : G₀ | x ≤ g} (· > ·) ↔ Nonempty (G₀ ≃*o ℤᵐ⁰) := by
have hg' : g⁻¹ ≠ 0 := by simp [hg]
rw [← wellFoundedOn_... | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | LinearOrderedCommGroupWithZero.wellFoundedOn_setOf_ge_gt_iff_nonempty_discrete_of_ne_zero | null |
instWellFoundedGTWithZeroMultiplicativeIntLeOne :
WellFoundedGT { v : ℤᵐ⁰ // v ≤ 1 } :=
{ wf :=
(LinearOrderedCommGroupWithZero.wellFoundedOn_setOf_ge_gt_iff_nonempty_discrete_of_ne_zero
one_ne_zero).mpr instNonemptyOfInhabited } | instance | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | instWellFoundedGTWithZeroMultiplicativeIntLeOne | null |
@[to_additive]
OrderMonoidIso.mulArchimedean {α β}
[CommMonoid α] [PartialOrder α] [CommMonoid β] [PartialOrder β]
(e : α ≃*o β) [MulArchimedean α] : MulArchimedean β := by
constructor
intro x y hxy
replace hxy : 1 < e.symm y := by simp [← map_lt_map_iff e, hxy]
refine (MulArchimedean.arch (e.symm x) hx... | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | OrderMonoidIso.mulArchimedean | null |
WithZero.mulArchimedean_iff {α} [CommGroup α] [PartialOrder α] :
MulArchimedean (WithZero α) ↔ MulArchimedean α := by
constructor <;> intro _
· exact OrderMonoidIso.unitsWithZero.mulArchimedean
· infer_instance | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | WithZero.mulArchimedean_iff | null |
Units.mulArchimedean_iff {G₀} [LinearOrderedCommGroupWithZero G₀] :
MulArchimedean G₀ˣ ↔ MulArchimedean G₀ := by
constructor <;> intro _
· exact OrderMonoidIso.withZeroUnits.mulArchimedean
· infer_instance | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | Units.mulArchimedean_iff | null |
denselyOrdered_additive_iff : DenselyOrdered (Additive X) ↔ DenselyOrdered X := Iff.rfl | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | denselyOrdered_additive_iff | null |
denselyOrdered_multiplicative_iff : DenselyOrdered (Multiplicative X) ↔ DenselyOrdered X :=
Iff.rfl | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | denselyOrdered_multiplicative_iff | null |
WithZero.denselyOrdered_iff {M : Type*} [Preorder M] [NoMinOrder M] :
DenselyOrdered (WithZero M) ↔ DenselyOrdered M :=
WithBot.denselyOrdered_iff | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | WithZero.denselyOrdered_iff | null |
Int.not_denselyOrdered : ¬ DenselyOrdered ℤ :=
(LinearOrderedAddCommGroup.discrete_iff_not_denselyOrdered ℤ).mp ⟨.refl _⟩ | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | Int.not_denselyOrdered | null |
not_denselyOrdered_withZero_int : ¬ DenselyOrdered ℤᵐ⁰ :=
(LinearOrderedCommGroupWithZero.discrete_iff_not_denselyOrdered _).mp ⟨.refl _⟩ | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | not_denselyOrdered_withZero_int | null |
WithZero.denselyOrdered_set_iff_subsingleton {X : Type*} [LinearOrder X]
[LocallyFiniteOrder X] {s : Set (WithZero X)} :
DenselyOrdered s ↔ s.Subsingleton :=
WithBot.denselyOrdered_set_iff_subsingleton | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | WithZero.denselyOrdered_set_iff_subsingleton | null |
sum_conjClasses_card_eq_card [Fintype <| ConjClasses G] [Fintype G]
[∀ x : ConjClasses G, Fintype x.carrier] :
∑ x : ConjClasses G, x.carrier.toFinset.card = Fintype.card G := by
suffices (Σ x : ConjClasses G, x.carrier) ≃ G by simpa using (Fintype.card_congr this)
simpa [carrier_eq_preimage_mk] using Equiv... | theorem | GroupTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.Group.ConjFinite",
"Mathlib.Algebra.Group.Subgroup.Finite",
"Mathlib.Data.Set.Card",
"Mathlib.GroupTheory.Subgroup.Center"
] | Mathlib/GroupTheory/ClassEquation.lean | sum_conjClasses_card_eq_card | Conjugacy classes form a partition of G, stated in terms of cardinality. |
Group.sum_card_conj_classes_eq_card [Finite G] :
∑ᶠ x : ConjClasses G, x.carrier.ncard = Nat.card G := by
classical
cases nonempty_fintype G
rw [Nat.card_eq_fintype_card, ← sum_conjClasses_card_eq_card, finsum_eq_sum_of_fintype]
simp [Set.ncard_eq_toFinset_card'] | theorem | GroupTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.Group.ConjFinite",
"Mathlib.Algebra.Group.Subgroup.Finite",
"Mathlib.Data.Set.Card",
"Mathlib.GroupTheory.Subgroup.Center"
] | Mathlib/GroupTheory/ClassEquation.lean | Group.sum_card_conj_classes_eq_card | Conjugacy classes form a partition of G, stated in terms of cardinality. |
Group.nat_card_center_add_sum_card_noncenter_eq_card [Finite G] :
Nat.card (Subgroup.center G) + ∑ᶠ x ∈ noncenter G, Nat.card x.carrier = Nat.card G := by
classical
cases nonempty_fintype G
rw [@Nat.card_eq_fintype_card G, ← sum_conjClasses_card_eq_card, ←
Finset.sum_sdiff (ConjClasses.noncenter G).toFins... | theorem | GroupTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.Group.ConjFinite",
"Mathlib.Algebra.Group.Subgroup.Finite",
"Mathlib.Data.Set.Card",
"Mathlib.GroupTheory.Subgroup.Center"
] | Mathlib/GroupTheory/ClassEquation.lean | Group.nat_card_center_add_sum_card_noncenter_eq_card | The **class equation** for finite groups. The cardinality of a group is equal to the size
of its center plus the sum of the size of all its nontrivial conjugacy classes. |
Group.card_center_add_sum_card_noncenter_eq_card (G) [Group G]
[∀ x : ConjClasses G, Fintype x.carrier] [Fintype G] [Fintype <| Subgroup.center G]
[Fintype <| noncenter G] : Fintype.card (Subgroup.center G) +
∑ x ∈ (noncenter G).toFinset, x.carrier.toFinset.card = Fintype.card G := by
convert Group.nat_ca... | theorem | GroupTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.Group.ConjFinite",
"Mathlib.Algebra.Group.Subgroup.Finite",
"Mathlib.Data.Set.Card",
"Mathlib.GroupTheory.Subgroup.Center"
] | Mathlib/GroupTheory/ClassEquation.lean | Group.card_center_add_sum_card_noncenter_eq_card | null |
Subgroup.quotConjEquiv (H K : Subgroup G) (g : ConjAct G) :
K ⧸ H.subgroupOf K ≃ (g • K : Subgroup G) ⧸ (g • H).subgroupOf (g • K) :=
Quotient.congr (K.equivSMul g).toEquiv fun a b ↦ by
dsimp
rw [← Quotient.eq'', ← Quotient.eq'', QuotientGroup.eq, QuotientGroup.eq,
mem_subgroupOf, mem_subgroupOf, ← ... | def | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Commensurable.lean | Subgroup.quotConjEquiv | Equivalence of `K / (H ⊓ K)` with `gKg⁻¹/ (gHg⁻¹ ⊓ gKg⁻¹)` |
@[to_additive /-- Two subgroups `H K` of `G` are commensurable if `H ⊓ K` has finite index in both
`H` and `K`. -/]
Subgroup.Commensurable (H K : Subgroup G) : Prop :=
H.relIndex K ≠ 0 ∧ K.relIndex H ≠ 0
@[deprecated (since := "2025-09-17")] alias Commensurable := Subgroup.Commensurable | def | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Commensurable.lean | Subgroup.Commensurable | Two subgroups `H K` of `G` are commensurable if `H ⊓ K` has finite index in both `H` and `K`. |
@[to_additive (attr := refl)]
protected refl (H : Subgroup G) : Commensurable H H := by simp [Commensurable]
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Commensurable.lean | refl | null |
comm {H K : Subgroup G} : Commensurable H K ↔ Commensurable K H := and_comm
@[to_additive (attr := symm)] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Commensurable.lean | comm | null |
symm {H K : Subgroup G} : Commensurable H K → Commensurable K H := And.symm
@[to_additive (attr := trans)] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Commensurable.lean | symm | null |
trans {H K L : Subgroup G} (hhk : Commensurable H K) (hkl : Commensurable K L) :
Commensurable H L :=
⟨Subgroup.relIndex_ne_zero_trans hhk.1 hkl.1, Subgroup.relIndex_ne_zero_trans hkl.2 hhk.2⟩
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Commensurable.lean | trans | null |
equivalence : Equivalence (@Commensurable G _) :=
⟨Commensurable.refl, fun h => Commensurable.symm h, fun h₁ h₂ => Commensurable.trans h₁ h₂⟩ | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Commensurable.lean | equivalence | null |
commensurable_conj {H K : Subgroup G} (g : ConjAct G) :
Commensurable H K ↔ Commensurable (g • H) (g • K) :=
and_congr (not_iff_not.mpr (Eq.congr_left (Cardinal.toNat_congr (quotConjEquiv H K g))))
(not_iff_not.mpr (Eq.congr_left (Cardinal.toNat_congr (quotConjEquiv K H g)))) | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Commensurable.lean | commensurable_conj | null |
conj {H K : Subgroup G} (h : Commensurable H K) (g : ConjAct G) :
Commensurable (g • H) (g • K) :=
(commensurable_conj g).mp h | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Commensurable.lean | conj | Alias for the forward direction of `commensurable_conj` to allow dot-notation |
commensurable_inv (H : Subgroup G) (g : ConjAct G) :
Commensurable (g • H) H ↔ Commensurable H (g⁻¹ • H) := by rw [commensurable_conj, inv_smul_smul] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Commensurable.lean | commensurable_inv | null |
commensurator' (H : Subgroup G) : Subgroup (ConjAct G) where
carrier := { g : ConjAct G | Commensurable (g • H) H }
one_mem' := by rw [Set.mem_setOf_eq, one_smul]
mul_mem' ha hb := by
rw [Set.mem_setOf_eq, mul_smul]
exact trans ((commensurable_conj _).mp hb) ha
inv_mem' _ := by rwa [Set.mem_setOf_eq, co... | def | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Commensurable.lean | commensurator' | For `H` a subgroup of `G`, this is the subgroup of all elements `g : conjAut G`
such that `Commensurable (g • H) H` |
commensurator (H : Subgroup G) : Subgroup G :=
(commensurator' H).comap ConjAct.toConjAct.toMonoidHom
@[simp] | def | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Commensurable.lean | commensurator | For `H` a subgroup of `G`, this is the subgroup of all elements `g : G`
such that `Commensurable (g H g⁻¹) H` |
commensurator'_mem_iff (H : Subgroup G) (g : ConjAct G) :
g ∈ commensurator' H ↔ Commensurable (g • H) H := Iff.rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Commensurable.lean | commensurator'_mem_iff | null |
commensurator_mem_iff (H : Subgroup G) (g : G) :
g ∈ commensurator H ↔ Commensurable (ConjAct.toConjAct g • H) H := Iff.rfl | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Commensurable.lean | commensurator_mem_iff | null |
eq {H K : Subgroup G} (hk : Commensurable H K) : commensurator H = commensurator K :=
Subgroup.ext fun x =>
let hx := (commensurable_conj x).1 hk
⟨fun h => hx.symm.trans (h.trans hk), fun h => hx.trans (h.trans hk.symm)⟩ | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Commensurable.lean | eq | null |
commProb : ℚ :=
Nat.card { p : M × M // Commute p.1 p.2 } / (Nat.card M : ℚ) ^ 2 | def | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | commProb | The commuting probability of a finite type with a multiplication operation. |
commProb_def :
commProb M = Nat.card { p : M × M // Commute p.1 p.2 } / (Nat.card M : ℚ) ^ 2 :=
rfl | theorem | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | commProb_def | null |
commProb_prod (M' : Type*) [Mul M'] : commProb (M × M') = commProb M * commProb M' := by
simp_rw [commProb_def, div_mul_div_comm, Nat.card_prod, Nat.cast_mul, mul_pow, ← Nat.cast_mul,
← Nat.card_prod, Commute, SemiconjBy, Prod.ext_iff]
congr 2
exact Nat.card_congr ⟨fun x => ⟨⟨⟨x.1.1.1, x.1.2.1⟩, x.2.1⟩, ⟨⟨x.1... | theorem | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | commProb_prod | null |
commProb_pi {α : Type*} (i : α → Type*) [Fintype α] [∀ a, Mul (i a)] :
commProb (∀ a, i a) = ∏ a, commProb (i a) := by
simp_rw [commProb_def, Finset.prod_div_distrib, Finset.prod_pow, ← Nat.cast_prod,
← Nat.card_pi, Commute, SemiconjBy, funext_iff]
congr 2
exact Nat.card_congr ⟨fun x a => ⟨⟨x.1.1 a, x.1.2... | theorem | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | commProb_pi | null |
commProb_function {α β : Type*} [Fintype α] [Mul β] :
commProb (α → β) = (commProb β) ^ Fintype.card α := by
rw [commProb_pi, Finset.prod_const, Finset.card_univ]
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | commProb_function | null |
commProb_eq_zero_of_infinite [Infinite M] : commProb M = 0 :=
div_eq_zero_iff.2 (Or.inl (Nat.cast_eq_zero.2 Nat.card_eq_zero_of_infinite))
variable [Finite M] | theorem | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | commProb_eq_zero_of_infinite | null |
commProb_pos [h : Nonempty M] : 0 < commProb M :=
h.elim fun x ↦
div_pos (Nat.cast_pos.mpr (Finite.card_pos_iff.mpr ⟨⟨(x, x), rfl⟩⟩))
(pow_pos (Nat.cast_pos.mpr Finite.card_pos) 2) | theorem | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | commProb_pos | null |
commProb_le_one : commProb M ≤ 1 := by
refine div_le_one_of_le₀ ?_ (sq_nonneg (Nat.card M : ℚ))
rw [← Nat.cast_pow, Nat.cast_le, sq, ← Nat.card_prod]
apply Finite.card_subtype_le
variable {M} | theorem | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | commProb_le_one | null |
commProb_eq_one_iff [h : Nonempty M] :
commProb M = 1 ↔ Std.Commutative ((· * ·) : M → M → M) := by
classical
haveI := Fintype.ofFinite M
rw [commProb, ← Set.coe_setOf, Nat.card_eq_fintype_card, Nat.card_eq_fintype_card]
rw [div_eq_one_iff_eq, ← Nat.cast_pow, Nat.cast_inj, sq, ← card_prod,
set_fintype_c... | theorem | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | commProb_eq_one_iff | null |
commProb_def' : commProb G = Nat.card (ConjClasses G) / Nat.card G := by
rw [commProb, card_comm_eq_card_conjClasses_mul_card, Nat.cast_mul, sq]
by_cases h : (Nat.card G : ℚ) = 0
· rw [h, zero_mul, div_zero, div_zero]
· exact mul_div_mul_right _ _ h
variable {G}
variable [Finite G] (H : Subgroup G) | theorem | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | commProb_def' | null |
Subgroup.commProb_subgroup_le : commProb H ≤ commProb G * (H.index : ℚ) ^ 2 := by
/- After rewriting with `commProb_def`, we reduce to showing that `G` has at least as many
commuting pairs as `H`. -/
rw [commProb_def, commProb_def, div_le_iff₀, mul_assoc, ← mul_pow, ← Nat.cast_mul,
mul_comm H.index, H.car... | theorem | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | Subgroup.commProb_subgroup_le | null |
Subgroup.commProb_quotient_le [H.Normal] : commProb (G ⧸ H) ≤ commProb G * Nat.card H := by
/- After rewriting with `commProb_def'`, we reduce to showing that `G` has at least as many
conjugacy classes as `G ⧸ H`. -/
rw [commProb_def', commProb_def', div_le_iff₀, mul_assoc, ← Nat.cast_mul, ← Subgroup.index,
... | theorem | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | Subgroup.commProb_quotient_le | null |
inv_card_commutator_le_commProb : (↑(Nat.card (commutator G)))⁻¹ ≤ commProb G :=
(inv_le_iff_one_le_mul₀ (Nat.cast_pos.mpr Finite.card_pos)).mpr
(le_trans (ge_of_eq (commProb_eq_one_iff.mpr ⟨(Abelianization.commGroup G).mul_comm⟩))
(commutator G).commProb_quotient_le) | theorem | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | inv_card_commutator_le_commProb | null |
commProb_odd {n : ℕ} (hn : Odd n) :
commProb (DihedralGroup n) = (n + 3) / (4 * n) := by
rw [commProb_def', DihedralGroup.card_conjClasses_odd hn, nat_card]
qify [show 2 ∣ n + 3 by rw [Nat.dvd_iff_mod_eq_zero, Nat.add_mod, Nat.odd_iff.mp hn]]
rw [div_div, ← mul_assoc]
congr
norm_num | lemma | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | commProb_odd | null |
private div_two_lt {n : ℕ} (h0 : n ≠ 0) : n / 2 < n :=
Nat.div_lt_self (Nat.pos_of_ne_zero h0) (lt_add_one 1) | lemma | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | div_two_lt | null |
private div_four_lt : {n : ℕ} → (h0 : n ≠ 0) → (h1 : n ≠ 1) → n / 4 + 1 < n
| 0 | 1 | 2 | 3 => by decide
| n + 4 => by cutsat | lemma | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | div_four_lt | null |
reciprocalFactors (n : ℕ) : List ℕ :=
if _ : n = 0 then [0]
else if _ : n = 1 then []
else if Even n then
3 :: reciprocalFactors (n / 2)
else
n % 4 * n :: reciprocalFactors (n / 4 + 1)
@[simp] lemma reciprocalFactors_zero : reciprocalFactors 0 = [0] := by
unfold reciprocalFactors; rfl
@[simp] lemma re... | def | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | reciprocalFactors | A list of Dihedral groups whose product will have commuting probability `1 / n`. |
reciprocalFactors_even {n : ℕ} (h0 : n ≠ 0) (h2 : Even n) :
reciprocalFactors n = 3 :: reciprocalFactors (n / 2) := by
have h1 : n ≠ 1 := by
rintro rfl
norm_num at h2
rw [reciprocalFactors, dif_neg h0, dif_neg h1, if_pos h2] | lemma | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | reciprocalFactors_even | null |
reciprocalFactors_odd {n : ℕ} (h1 : n ≠ 1) (h2 : Odd n) :
reciprocalFactors n = n % 4 * n :: reciprocalFactors (n / 4 + 1) := by
have h0 : n ≠ 0 := by
rintro rfl
norm_num [← Nat.not_even_iff_odd] at h2
rw [reciprocalFactors, dif_neg h0, dif_neg h1, if_neg (Nat.not_even_iff_odd.2 h2)] | lemma | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | reciprocalFactors_odd | null |
Product (l : List ℕ) : Type :=
∀ i : Fin l.length, DihedralGroup l[i] | abbrev | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | Product | A finite product of Dihedral groups. |
commProb_nil : commProb (Product []) = 1 := by
simp [Product, commProb_pi] | lemma | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | commProb_nil | null |
commProb_cons (n : ℕ) (l : List ℕ) :
commProb (Product (n :: l)) = commProb (DihedralGroup n) * commProb (Product l) := by
simp only [commProb_pi, Fin.prod_univ_succ, Fin.getElem_fin, Fin.val_succ, Fin.val_zero,
List.getElem_cons_zero, List.length_cons, List.getElem_cons_succ] | lemma | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | commProb_cons | null |
commProb_reciprocal (n : ℕ) :
commProb (Product (reciprocalFactors n)) = 1 / n := by
by_cases h0 : n = 0
· rw [h0, reciprocalFactors_zero, commProb_cons, commProb_nil, mul_one, Nat.cast_zero, div_zero]
apply commProb_eq_zero_of_infinite
by_cases h1 : n = 1
· rw [h1, reciprocalFactors_one, commProb_nil, ... | theorem | GroupTheory | [
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.GroupTheory.Abelianization.Finite",
"Mathlib.GroupTheory.SpecificGroups.Dihedral",
"Mathlib.Tactic.FieldSimp",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.Qify"
] | Mathlib/GroupTheory/CommutingProbability.lean | commProb_reciprocal | Construction of a group with commuting probability `1 / n`. |
@[to_additive /-- `S` and `T` are complements if `(+) : S × T → G` is a bijection
If `S` and `T` are `SetLike`s such as `AddSubgroup`s, see `isComplement_iff_bijective` for a
more ergonomic way to unfold. -/]
IsComplement : Prop :=
Function.Bijective fun x : S × T => x.1.1 * x.2.1 | def | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | IsComplement | `S` and `T` are complements if `(*) : S × T → G` is a bijection.
This notion generalizes left transversals, right transversals, and complementary subgroups.
If `S` and `T` are `SetLike`s such as `Subgroup`s, see `isComplement_iff_bijective` for a
more ergonomic way to unfold. |
@[to_additive /-- `H` and `K` are complements if `(+) : H × K → G` is a bijection -/]
IsComplement' :=
IsComplement (H : Set G) (K : Set G)
variable {H K S T} | abbrev | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | IsComplement' | `H` and `K` are complements if `(*) : H × K → G` is a bijection |
@[to_additive /-- The correct way to unfold `IsComplement` for `SetLike`s such as `AddSubgroup`s -/]
isComplement_iff_bijective {S : Type*} [SetLike S G] (s t : S) :
IsComplement (G := G) s t ↔ Function.Bijective fun x : s × t => (x.1 : G) * (x.2 : G) :=
Iff.rfl
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement_iff_bijective | The correct way to unfold `IsComplement` for `SetLike`s such as `Subgroup`s |
isComplement'_def : IsComplement' H K ↔ IsComplement (H : Set G) (K : Set G) :=
Iff.rfl
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement'_def | null |
isComplement_iff_existsUnique :
IsComplement S T ↔ ∀ g : G, ∃! x : S × T, x.1.1 * x.2.1 = g :=
Function.bijective_iff_existsUnique _
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement_iff_existsUnique | null |
IsComplement.existsUnique (h : IsComplement S T) (g : G) :
∃! x : S × T, x.1.1 * x.2.1 = g :=
isComplement_iff_existsUnique.mp h g
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | IsComplement.existsUnique | null |
IsComplement'.symm (h : IsComplement' H K) : IsComplement' K H := by
let ϕ : H × K ≃ K × H :=
Equiv.mk (fun x => ⟨x.2⁻¹, x.1⁻¹⟩) (fun x => ⟨x.2⁻¹, x.1⁻¹⟩)
(fun x => Prod.ext (inv_inv _) (inv_inv _)) fun x => Prod.ext (inv_inv _) (inv_inv _)
let ψ : G ≃ G := Equiv.mk (fun g : G => g⁻¹) (fun g : G => g⁻¹) i... | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | IsComplement'.symm | null |
isComplement'_comm : IsComplement' H K ↔ IsComplement' K H :=
⟨IsComplement'.symm, IsComplement'.symm⟩
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement'_comm | null |
isComplement_univ_singleton {g : G} : IsComplement (univ : Set G) {g} :=
⟨fun ⟨_, _, rfl⟩ ⟨_, _, rfl⟩ h => Prod.ext (Subtype.ext (mul_right_cancel h)) rfl, fun x =>
⟨⟨⟨x * g⁻¹, ⟨⟩⟩, g, rfl⟩, inv_mul_cancel_right x g⟩⟩
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement_univ_singleton | null |
isComplement_singleton_univ {g : G} : IsComplement ({g} : Set G) univ :=
⟨fun ⟨⟨_, rfl⟩, _⟩ ⟨⟨_, rfl⟩, _⟩ h => Prod.ext rfl (Subtype.ext (mul_left_cancel h)), fun x =>
⟨⟨⟨g, rfl⟩, g⁻¹ * x, ⟨⟩⟩, mul_inv_cancel_left g x⟩⟩
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement_singleton_univ | null |
isComplement_singleton_left {g : G} : IsComplement {g} S ↔ S = univ := by
refine
⟨fun h => top_le_iff.mp fun x _ => ?_, fun h => (congr_arg _ h).mpr isComplement_singleton_univ⟩
obtain ⟨⟨⟨z, rfl : z = g⟩, y, _⟩, hy⟩ := h.2 (g * x)
rwa [← mul_left_cancel hy]
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement_singleton_left | null |
isComplement_singleton_right {g : G} : IsComplement S {g} ↔ S = univ := by
refine
⟨fun h => top_le_iff.mp fun x _ => ?_, fun h => h ▸ isComplement_univ_singleton⟩
obtain ⟨y, hy⟩ := h.2 (x * g)
conv_rhs at hy => rw [← show y.2.1 = g from y.2.2]
rw [← mul_right_cancel hy]
exact y.1.2
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement_singleton_right | null |
isComplement_univ_left : IsComplement univ S ↔ ∃ g : G, S = {g} := by
refine
⟨fun h => Set.exists_eq_singleton_iff_nonempty_subsingleton.mpr ⟨?_, fun a ha b hb => ?_⟩, ?_⟩
· obtain ⟨a, _⟩ := h.2 1
exact ⟨a.2.1, a.2.2⟩
· have : (⟨⟨_, mem_top a⁻¹⟩, ⟨a, ha⟩⟩ : (⊤ : Set G) × S) = ⟨⟨_, mem_top b⁻¹⟩, ⟨b, hb⟩⟩ :... | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement_univ_left | null |
isComplement_univ_right : IsComplement S univ ↔ ∃ g : G, S = {g} := by
refine
⟨fun h => Set.exists_eq_singleton_iff_nonempty_subsingleton.mpr ⟨?_, fun a ha b hb => ?_⟩, ?_⟩
· obtain ⟨a, _⟩ := h.2 1
exact ⟨a.1.1, a.1.2⟩
· have : (⟨⟨a, ha⟩, ⟨_, mem_top a⁻¹⟩⟩ : S × (⊤ : Set G)) = ⟨⟨b, hb⟩, ⟨_, mem_top b⁻¹⟩⟩ ... | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement_univ_right | null |
IsComplement.mul_eq (h : IsComplement S T) : S * T = univ :=
eq_univ_of_forall fun x ↦ by simpa [mem_mul] using (h.existsUnique x).exists
@[to_additive (attr := simp)] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | IsComplement.mul_eq | null |
not_isComplement_empty_left : ¬ IsComplement ∅ T :=
fun h ↦ by simpa [eq_comm (a := ∅)] using h.mul_eq
@[to_additive (attr := simp)] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | not_isComplement_empty_left | null |
not_isComplement_empty_right : ¬ IsComplement S ∅ :=
fun h ↦ by simpa [eq_comm (a := ∅)] using h.mul_eq
@[to_additive] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | not_isComplement_empty_right | null |
IsComplement.nonempty_left (hst : IsComplement S T) : S.Nonempty := by
contrapose! hst; simp [hst]
@[to_additive] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | IsComplement.nonempty_left | null |
IsComplement.nonempty_right (hst : IsComplement S T) : T.Nonempty := by
contrapose! hst; simp [hst]
@[to_additive] lemma IsComplement.pairwiseDisjoint_smul (hst : IsComplement S T) :
S.PairwiseDisjoint (· • T) := fun a ha b hb hab ↦ disjoint_iff_forall_ne.2 <| by
rintro _ ⟨c, hc, rfl⟩ _ ⟨d, hd, rfl⟩
exact hst... | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | IsComplement.nonempty_right | null |
IsComplement.card_mul_card (h : IsComplement S T) : Nat.card S * Nat.card T = Nat.card G :=
(Nat.card_prod _ _).symm.trans <| Nat.card_congr <| Equiv.ofBijective _ h
@[to_additive] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | IsComplement.card_mul_card | null |
isComplement'_top_bot : IsComplement' (⊤ : Subgroup G) ⊥ :=
isComplement_univ_singleton
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement'_top_bot | null |
isComplement'_bot_top : IsComplement' (⊥ : Subgroup G) ⊤ :=
isComplement_singleton_univ
@[to_additive (attr := simp)] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement'_bot_top | null |
isComplement'_bot_left : IsComplement' ⊥ H ↔ H = ⊤ :=
isComplement_singleton_left.trans coe_eq_univ
@[to_additive (attr := simp)] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement'_bot_left | null |
isComplement'_bot_right : IsComplement' H ⊥ ↔ H = ⊤ :=
isComplement_singleton_right.trans coe_eq_univ
@[to_additive (attr := simp)] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement'_bot_right | null |
isComplement'_top_left : IsComplement' ⊤ H ↔ H = ⊥ :=
isComplement_univ_left.trans coe_eq_singleton
@[to_additive (attr := simp)] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement'_top_left | null |
isComplement'_top_right : IsComplement' H ⊤ ↔ H = ⊥ :=
isComplement_univ_right.trans coe_eq_singleton
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement'_top_right | null |
isComplement_iff_existsUnique_inv_mul_mem :
IsComplement S T ↔ ∀ g, ∃! s : S, (s : G)⁻¹ * g ∈ T := by
convert isComplement_iff_existsUnique with g
constructor <;> rintro ⟨x, hx, hx'⟩
· exact ⟨(x, ⟨_, hx⟩), by simp, by aesop⟩
· exact ⟨x.1, by simp [← hx], fun y hy ↦ (Prod.ext_iff.1 <| by simpa using hx' (y, ... | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement_iff_existsUnique_inv_mul_mem | null |
isComplement_iff_existsUnique_mul_inv_mem :
IsComplement S T ↔ ∀ g, ∃! t : T, g * (t : G)⁻¹ ∈ S := by
convert isComplement_iff_existsUnique with g
constructor <;> rintro ⟨x, hx, hx'⟩
· exact ⟨(⟨_, hx⟩, x), by simp, by aesop⟩
· exact ⟨x.2, by simp [← hx], fun y hy ↦ (Prod.ext_iff.1 <| by simpa using hx' (⟨_,... | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement_iff_existsUnique_mul_inv_mem | null |
isComplement_subgroup_right_iff_existsUnique_quotientGroupMk :
IsComplement S H ↔ ∀ q : G ⧸ H, ∃! s : S, QuotientGroup.mk s.1 = q := by
simp_rw [isComplement_iff_existsUnique_inv_mul_mem, SetLike.mem_coe, ← QuotientGroup.eq,
QuotientGroup.forall_mk]
set_option linter.docPrime false in
@[to_additive] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement_subgroup_right_iff_existsUnique_quotientGroupMk | null |
isComplement_subgroup_left_iff_existsUnique_quotientMk'' :
IsComplement H T ↔
∀ q : Quotient (QuotientGroup.rightRel H), ∃! t : T, Quotient.mk'' t.1 = q := by
simp_rw [isComplement_iff_existsUnique_mul_inv_mem, SetLike.mem_coe,
← QuotientGroup.rightRel_apply, ← Quotient.eq'', Quotient.forall]
@[to_addit... | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement_subgroup_left_iff_existsUnique_quotientMk'' | null |
isComplement_subgroup_right_iff_bijective :
IsComplement S H ↔ Bijective (S.restrict (QuotientGroup.mk : G → G ⧸ H)) :=
isComplement_subgroup_right_iff_existsUnique_quotientGroupMk.trans
(bijective_iff_existsUnique (S.restrict QuotientGroup.mk)).symm
@[to_additive] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement_subgroup_right_iff_bijective | null |
isComplement_subgroup_left_iff_bijective :
IsComplement H T ↔
Bijective (T.restrict (Quotient.mk'' : G → Quotient (QuotientGroup.rightRel H))) :=
isComplement_subgroup_left_iff_existsUnique_quotientMk''.trans
(bijective_iff_existsUnique (T.restrict Quotient.mk'')).symm
@[to_additive] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement_subgroup_left_iff_bijective | null |
IsComplement.card_left (h : IsComplement S H) : Nat.card S = H.index :=
Nat.card_congr <| .ofBijective _ <| isComplement_subgroup_right_iff_bijective.mp h
@[to_additive] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | IsComplement.card_left | null |
IsComplement.ncard_left (h : IsComplement S H) : S.ncard = H.index := by
rw [← Nat.card_coe_set_eq, h.card_left]
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | IsComplement.ncard_left | null |
IsComplement.card_right (h : IsComplement H T) : Nat.card T = H.index :=
Nat.card_congr <| (Equiv.ofBijective _ <| isComplement_subgroup_left_iff_bijective.mp h).trans <|
QuotientGroup.quotientRightRelEquivQuotientLeftRel H
@[to_additive] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | IsComplement.card_right | null |
IsComplement.ncard_right (h : IsComplement H T) : T.ncard = H.index := by
rw [← Nat.card_coe_set_eq, h.card_right]
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | IsComplement.ncard_right | null |
isComplement_range_left {f : G ⧸ H → G} (hf : ∀ q, ↑(f q) = q) :
IsComplement (range f) H := by
rw [isComplement_subgroup_right_iff_bijective]
refine ⟨?_, fun q ↦ ⟨⟨f q, q, rfl⟩, hf q⟩⟩
rintro ⟨-, q₁, rfl⟩ ⟨-, q₂, rfl⟩ h
exact Subtype.ext <| congr_arg f <| ((hf q₁).symm.trans h).trans (hf q₂)
@[to_additive] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement_range_left | null |
isComplement_range_right {f : Quotient (QuotientGroup.rightRel H) → G}
(hf : ∀ q, Quotient.mk'' (f q) = q) : IsComplement H (range f) := by
rw [isComplement_subgroup_left_iff_bijective]
refine ⟨?_, fun q ↦ ⟨⟨f q, q, rfl⟩, hf q⟩⟩
rintro ⟨-, q₁, rfl⟩ ⟨-, q₂, rfl⟩ h
exact Subtype.ext <| congr_arg f <| ((hf q₁)... | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | isComplement_range_right | null |
exists_isComplement_left (H : Subgroup G) (g : G) : ∃ S, IsComplement S H ∧ g ∈ S := by
classical
refine ⟨Set.range (Function.update Quotient.out _ g), isComplement_range_left fun q ↦ ?_,
QuotientGroup.mk g, Function.update_self (Quotient.mk'' g) g Quotient.out⟩
by_cases hq : q = Quotient.mk'' g
· exact hq.... | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | exists_isComplement_left | null |
exists_isComplement_right (H : Subgroup G) (g : G) :
∃ T, IsComplement H T ∧ g ∈ T := by
classical
refine ⟨Set.range (Function.update Quotient.out _ g), isComplement_range_right fun q ↦ ?_,
Quotient.mk'' g, Function.update_self (Quotient.mk'' g) g Quotient.out⟩
by_cases hq : q = Quotient.mk'' g
· exact ... | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | exists_isComplement_right | null |
@[to_additive /-- Given two subgroups `H' ⊆ H`, there exists a transversal to `H'` inside `H` -/]
exists_left_transversal_of_le {H' H : Subgroup G} (h : H' ≤ H) :
∃ S : Set G, S * H' = H ∧ Nat.card S * Nat.card H' = Nat.card H := by
let H'' : Subgroup H := H'.comap H.subtype
have : H' = H''.map H.subtype := by ... | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | exists_left_transversal_of_le | Given two subgroups `H' ⊆ H`, there exists a left transversal to `H'` inside `H`. |
@[to_additive /-- Given two subgroups `H' ⊆ H`, there exists a transversal to `H'` inside `H` -/]
exists_right_transversal_of_le {H' H : Subgroup G} (h : H' ≤ H) :
∃ S : Set G, H' * S = H ∧ Nat.card H' * Nat.card S = Nat.card H := by
let H'' : Subgroup H := H'.comap H.subtype
have : H' = H''.map H.subtype := by... | lemma | GroupTheory | [
"Mathlib.GroupTheory.Index"
] | Mathlib/GroupTheory/Complement.lean | exists_right_transversal_of_le | Given two subgroups `H' ⊆ H`, there exists a right transversal to `H'` inside `H`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.