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 ⌀ |
|---|---|---|---|---|---|---|
map (f : α → β) : FreeAbelianGroup α →+ FreeAbelianGroup β :=
lift (of ∘ f) | def | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | map | The additive group homomorphism `FreeAbelianGroup α →+ FreeAbelianGroup β` induced from a
map `α → β`. |
lift_comp {α} {β} {γ} [AddCommGroup γ] (f : α → β) (g : β → γ) (x : FreeAbelianGroup α) :
lift (g ∘ f) x = lift g (map f x) := by
induction x using FreeAbelianGroup.induction_on with
| C0 => simp only [map_zero]
| C1 => simp only [lift_apply_of, map, Function.comp]
| Cn _ h => simp only [h, AddMonoidHom.map_neg]
| Cp _ _ h₁ h₂ => simp only [h₁, h₂, AddMonoidHom.map_add] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | lift_comp | null |
map_id : map id = AddMonoidHom.id (FreeAbelianGroup α) :=
Eq.symm <|
lift_ext _ _ fun _ ↦ lift_unique of (AddMonoidHom.id _) fun _ ↦ AddMonoidHom.id_apply _ _ | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | map_id | null |
map_id_apply (x : FreeAbelianGroup α) : map id x = x := by
rw [map_id]
rfl | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | map_id_apply | null |
map_comp {f : α → β} {g : β → γ} : map (g ∘ f) = (map g).comp (map f) :=
Eq.symm <| lift_ext _ _ fun _ ↦ by simp [map] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | map_comp | null |
map_comp_apply {f : α → β} {g : β → γ} (x : FreeAbelianGroup α) :
map (g ∘ f) x = (map g) ((map f) x) := by
rw [map_comp]
rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | map_comp_apply | null |
map_of_apply {f : α → β} (a : α) : map f (of a) = of (f a) :=
rfl
variable (α) | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | map_of_apply | null |
mul : Mul (FreeAbelianGroup α) :=
⟨fun x ↦ lift fun x₂ ↦ lift (fun x₁ ↦ of (x₁ * x₂)) x⟩
variable {α} | instance | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | mul | null |
mul_def (x y : FreeAbelianGroup α) :
x * y = lift (fun x₂ ↦ lift (fun x₁ ↦ of (x₁ * x₂)) x) y :=
rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | mul_def | null |
of_mul_of (x y : α) : of x * of y = of (x * y) := by
rw [mul_def, lift_apply_of, lift_apply_of] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | of_mul_of | null |
of_mul (x y : α) : of (x * y) = of x * of y :=
Eq.symm <| of_mul_of x y | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | of_mul | null |
distrib : Distrib (FreeAbelianGroup α) :=
{ FreeAbelianGroup.mul α, FreeAbelianGroup.addCommGroup α with
left_distrib := fun _ _ _ ↦ (lift _).map_add _ _
right_distrib x y z := by simp [mul_def, ← Pi.add_def] } | instance | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | distrib | null |
nonUnitalNonAssocRing : NonUnitalNonAssocRing (FreeAbelianGroup α) :=
{ FreeAbelianGroup.distrib,
FreeAbelianGroup.addCommGroup _ with
zero_mul := fun a ↦ by
have h : 0 * a + 0 * a = 0 * a := by simp [← add_mul]
simpa using h
mul_zero := fun _ ↦ rfl } | instance | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | nonUnitalNonAssocRing | null |
one : One (FreeAbelianGroup α) :=
⟨of 1⟩ | instance | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | one | null |
one_def : (1 : FreeAbelianGroup α) = of 1 :=
rfl | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | one_def | null |
of_one : (of 1 : FreeAbelianGroup α) = 1 :=
rfl | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | of_one | null |
nonUnitalRing [Semigroup α] : NonUnitalRing (FreeAbelianGroup α) :=
{ FreeAbelianGroup.nonUnitalNonAssocRing with
mul_assoc := fun x y z ↦ by
refine FreeAbelianGroup.induction_on z (by simp only [mul_zero])
(fun L3 ↦ ?_) (fun L3 ih ↦ ?_) fun z₁ z₂ ih₁ ih₂ ↦ ?_
· refine FreeAbelianGroup.induction_on y (by simp only [mul_zero, zero_mul])
(fun L2 ↦ ?_) (fun L2 ih ↦ ?_) fun y₁ y₂ ih₁ ih₂ ↦ ?_
· refine FreeAbelianGroup.induction_on x (by simp only [zero_mul])
(fun L1 ↦ ?_) (fun L1 ih ↦ ?_) fun x₁ x₂ ih₁ ih₂ ↦ ?_
· rw [of_mul_of, of_mul_of, of_mul_of, of_mul_of, mul_assoc]
· rw [neg_mul, neg_mul, neg_mul, ih]
· rw [add_mul, add_mul, add_mul, ih₁, ih₂]
· rw [neg_mul, mul_neg, mul_neg, neg_mul, ih]
· rw [add_mul, mul_add, mul_add, add_mul, ih₁, ih₂]
· rw [mul_neg, mul_neg, mul_neg, ih]
· rw [mul_add, mul_add, mul_add, ih₁, ih₂] } | instance | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | nonUnitalRing | null |
ring : Ring (FreeAbelianGroup α) :=
{ FreeAbelianGroup.nonUnitalRing _,
FreeAbelianGroup.one _ with
mul_one := fun x ↦ by
rw [mul_def, one_def, lift_apply_of]
refine FreeAbelianGroup.induction_on x rfl (fun L ↦ ?_) (fun L ih ↦ ?_) fun x1 x2 ih1 ih2 ↦ ?_
· rw [lift_apply_of, mul_one]
· rw [map_neg, ih]
· rw [map_add, ih1, ih2]
one_mul := fun x ↦ by
simp_rw [mul_def, one_def, lift_apply_of]
refine FreeAbelianGroup.induction_on x rfl ?_ ?_ ?_
· intro L
rw [lift_apply_of, one_mul]
· intro L ih
rw [map_neg, ih]
· intro x1 x2 ih1 ih2
rw [map_add, ih1, ih2] }
variable {α} | instance | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | ring | null |
ofMulHom : α →* FreeAbelianGroup α where
toFun := of
map_one' := of_one _
map_mul' := of_mul
@[simp] | def | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | ofMulHom | `FreeAbelianGroup.of` is a `MonoidHom` when `α` is a `Monoid`. |
ofMulHom_coe : (ofMulHom : α → FreeAbelianGroup α) = of :=
rfl | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | ofMulHom_coe | null |
liftMonoid : (α →* R) ≃ (FreeAbelianGroup α →+* R) where
toFun f := { lift f with
toFun := lift f
map_one' := (lift_apply_of f _).trans f.map_one
map_mul' := fun x y ↦ by
refine FreeAbelianGroup.induction_on y
(by simp only [mul_zero, map_zero]) (fun L2 ↦ ?_) (fun L2 ih ↦ ?_) ?_
· refine FreeAbelianGroup.induction_on x
(by simp only [zero_mul, map_zero]) (fun L1 ↦ ?_) (fun L1 ih ↦ ?_) ?_
· simp_rw [of_mul_of, lift_apply_of]
exact f.map_mul _ _
· simp_rw [neg_mul, map_neg, neg_mul]
exact congr_arg Neg.neg ih
· intro x1 x2 ih1 ih2
simp only [add_mul, map_add, ih1, ih2]
· rw [mul_neg, map_neg, map_neg, mul_neg, ih]
· intro y1 y2 ih1 ih2
rw [mul_add, map_add, map_add, mul_add, ih1, ih2] }
invFun F := MonoidHom.comp (↑F) ofMulHom
left_inv f := MonoidHom.ext <| by
simp only [RingHom.coe_monoidHom_mk, MonoidHom.coe_comp, MonoidHom.coe_mk, OneHom.coe_mk,
ofMulHom_coe, Function.comp_apply, lift_apply_of, forall_const]
right_inv F := RingHom.coe_addMonoidHom_injective <| by
simp only
rw [← lift.apply_symm_apply (↑F : FreeAbelianGroup α →+ R)]
rfl
@[simp] | def | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | liftMonoid | If `f` preserves multiplication, then so does `lift f`. |
liftMonoid_coe_addMonoidHom (f : α →* R) : ↑(liftMonoid f) = lift f :=
rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | liftMonoid_coe_addMonoidHom | null |
liftMonoid_coe (f : α →* R) : ⇑(liftMonoid f) = lift f :=
rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | liftMonoid_coe | null |
liftMonoid_symm_coe (f : FreeAbelianGroup α →+* R) :
⇑(liftMonoid.symm f) = lift.symm f :=
rfl | theorem | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | liftMonoid_symm_coe | null |
pemptyUnique : Unique (FreeAbelianGroup PEmpty) where
default := 0
uniq x := FreeAbelianGroup.induction_on x rfl (PEmpty.elim ·) (PEmpty.elim ·) (by
rintro - - rfl rfl
rfl) | instance | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | pemptyUnique | null |
uniqueEquiv (T : Type*) [Unique T] : FreeAbelianGroup T ≃+ ℤ where
toFun := FreeAbelianGroup.lift fun _ ↦ (1 : ℤ)
invFun n := n • of Inhabited.default
left_inv z := FreeAbelianGroup.induction_on z
(by simp only [zero_smul, AddMonoidHom.map_zero])
(Unique.forall_iff.2 <| by simp only [one_smul, lift_apply_of]) (Unique.forall_iff.2 <| by simp)
fun x y hx hy ↦ by
simp only [AddMonoidHom.map_add, add_smul] at *
rw [hx, hy]
right_inv n := by
rw [AddMonoidHom.map_zsmul, lift_apply_of]
exact zsmul_int_one n
map_add' := AddMonoidHom.map_add _
@[deprecated (since := "2025-06-16")] alias punitEquiv := uniqueEquiv | def | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | uniqueEquiv | The free abelian group on a type with one term is isomorphic to `ℤ`. |
equivOfEquiv {α β : Type*} (f : α ≃ β) : FreeAbelianGroup α ≃+ FreeAbelianGroup β where
toFun := map f
invFun := map f.symm
left_inv x := by rw [← map_comp_apply, Equiv.symm_comp_self, map_id, AddMonoidHom.id_apply]
right_inv x := by rw [← map_comp_apply, Equiv.self_comp_symm, map_id, AddMonoidHom.id_apply]
map_add' := AddMonoidHom.map_add _ | def | GroupTheory | [
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.FreeGroup.Basic"
] | Mathlib/GroupTheory/FreeAbelianGroup.lean | equivOfEquiv | Isomorphic types have isomorphic free abelian groups. |
@[to_additive
/-- For `I` a subgroup of `G × H`, `I.goursatFst` is the kernel of the projection map `I → H`,
considered as a subgroup of `G`.
This is the first subgroup appearing in Goursat's lemma. See `AddSubgroup.goursat`. -/]
goursatFst : Subgroup G :=
((MonoidHom.snd G H).comp I.subtype).ker.map ((MonoidHom.fst G H).comp I.subtype)
variable (I) in | def | GroupTheory | [
"Mathlib.Algebra.Group.Graph",
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Goursat.lean | goursatFst | For `I` a subgroup of `G × H`, `I.goursatFst` is the kernel of the projection map `I → H`,
considered as a subgroup of `G`.
This is the first subgroup appearing in Goursat's lemma. See `Subgroup.goursat`. |
@[to_additive
/-- For `I` a subgroup of `G × H`, `I.goursatSnd` is the kernel of the projection map `I → G`,
considered as a subgroup of `H`.
This is the second subgroup appearing in Goursat's lemma. See `AddSubgroup.goursat`. -/]
goursatSnd : Subgroup H :=
((MonoidHom.fst G H).comp I.subtype).ker.map ((MonoidHom.snd G H).comp I.subtype)
@[to_additive (attr := simp)] | def | GroupTheory | [
"Mathlib.Algebra.Group.Graph",
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Goursat.lean | goursatSnd | For `I` a subgroup of `G × H`, `I.goursatSnd` is the kernel of the projection map `I → G`,
considered as a subgroup of `H`.
This is the second subgroup appearing in Goursat's lemma. See `Subgroup.goursat`. |
mem_goursatFst {g : G} : g ∈ I.goursatFst ↔ (g, 1) ∈ I := by simp [goursatFst]
@[to_additive (attr := simp)] | lemma | GroupTheory | [
"Mathlib.Algebra.Group.Graph",
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Goursat.lean | mem_goursatFst | null |
mem_goursatSnd {h : H} : h ∈ I.goursatSnd ↔ (1, h) ∈ I := by simp [goursatSnd]
include hI₁ in
@[to_additive] lemma normal_goursatFst : I.goursatFst.Normal := .map inferInstance _ hI₁
include hI₂ in
@[to_additive] lemma normal_goursatSnd : I.goursatSnd.Normal := .map inferInstance _ hI₂
include hI₁ hI₂ in
@[to_additive] | lemma | GroupTheory | [
"Mathlib.Algebra.Group.Graph",
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Goursat.lean | mem_goursatSnd | null |
mk_goursatFst_eq_iff_mk_goursatSnd_eq {x y : G × H} (hx : x ∈ I) (hy : y ∈ I) :
(x.1 : G ⧸ I.goursatFst) = y.1 ↔ (x.2 : H ⧸ I.goursatSnd) = y.2 := by
have := normal_goursatFst hI₁
have := normal_goursatSnd hI₂
rw [eq_comm]
simp only [QuotientGroup.eq_iff_div_mem, mem_goursatFst, mem_goursatSnd]
constructor <;> intro h
· simpa [Prod.mul_def, Prod.div_def] using div_mem (mul_mem h hx) hy
· simpa [Prod.mul_def, Prod.div_def] using div_mem (mul_mem h hy) hx
variable (I) in
@[to_additive AddSubgroup.goursatFst_prod_goursatSnd_le] | lemma | GroupTheory | [
"Mathlib.Algebra.Group.Graph",
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Goursat.lean | mk_goursatFst_eq_iff_mk_goursatSnd_eq | null |
goursatFst_prod_goursatSnd_le : I.goursatFst.prod I.goursatSnd ≤ I := by
rintro ⟨g, h⟩ ⟨hg, hh⟩
simpa using mul_mem (mem_goursatFst.1 hg) (mem_goursatSnd.1 hh) | lemma | GroupTheory | [
"Mathlib.Algebra.Group.Graph",
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Goursat.lean | goursatFst_prod_goursatSnd_le | null |
@[to_additive
/-- **Goursat's lemma** for a subgroup of a product with surjective projections.
If `I` is a subgroup of `G × H` which projects fully on both factors, then there exist normal
subgroups `M ≤ G` and `N ≤ H` such that `G' × H' ≤ I` and the image of `I` in `G ⧸ M × H ⧸ N` is the
graph of an isomorphism `G ⧸ M ≃ H ⧸ N'`.
`G'` and `H'` can be explicitly constructed as `I.goursatFst` and `I.goursatSnd` respectively. -/]
goursat_surjective :
have := normal_goursatFst hI₁
have := normal_goursatSnd hI₂
∃ e : G ⧸ I.goursatFst ≃* H ⧸ I.goursatSnd,
(((QuotientGroup.mk' _).prodMap (QuotientGroup.mk' _)).comp I.subtype).range =
e.toMonoidHom.graph := by
have := normal_goursatFst hI₁
have := normal_goursatSnd hI₂
exact (((QuotientGroup.mk' I.goursatFst).prodMap
(QuotientGroup.mk' I.goursatSnd)).comp I.subtype).exists_mulEquiv_range_eq_graph
((QuotientGroup.mk'_surjective _).comp hI₁) ((QuotientGroup.mk'_surjective _).comp hI₂)
fun ⟨x, hx⟩ ⟨y, hy⟩ ↦ mk_goursatFst_eq_iff_mk_goursatSnd_eq hI₁ hI₂ hx hy | lemma | GroupTheory | [
"Mathlib.Algebra.Group.Graph",
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Goursat.lean | goursat_surjective | **Goursat's lemma** for a subgroup of a product with surjective projections.
If `I` is a subgroup of `G × H` which projects fully on both factors, then there exist normal
subgroups `M ≤ G` and `N ≤ H` such that `G' × H' ≤ I` and the image of `I` in `G ⧸ M × H ⧸ N` is the
graph of an isomorphism `G ⧸ M ≃ H ⧸ N'`.
`G'` and `H'` can be explicitly constructed as `I.goursatFst` and `I.goursatSnd` respectively. |
@[to_additive
/-- **Goursat's lemma** for an arbitrary subgroup.
If `I` is a subgroup of `G × H`, then there exist subgroups `G' ≤ G`, `H' ≤ H` and normal subgroups
`M ≤ G'` and `N ≤ H'` such that `M × N ≤ I` and the image of `I` in `G' ⧸ M × H' ⧸ N` is the graph
of an isomorphism `G ⧸ G' ≃ H ⧸ H'`. -/]
goursat :
∃ (G' : Subgroup G) (H' : Subgroup H) (M : Subgroup G') (N : Subgroup H') (_ : M.Normal)
(_ : N.Normal) (e : G' ⧸ M ≃* H' ⧸ N),
I = (e.toMonoidHom.graph.comap <| (QuotientGroup.mk' M).prodMap (QuotientGroup.mk' N)).map
(G'.subtype.prodMap H'.subtype) := by
let G' := I.map (MonoidHom.fst ..)
let H' := I.map (MonoidHom.snd ..)
let P : I →* G' := (MonoidHom.fst ..).subgroupMap I
let Q : I →* H' := (MonoidHom.snd ..).subgroupMap I
let I' : Subgroup (G' × H') := (P.prod Q).range
have hI₁' : Surjective (Prod.fst ∘ I'.subtype) := by
simp only [← MonoidHom.coe_fst, ← MonoidHom.coe_comp, ← MonoidHom.range_eq_top,
MonoidHom.range_comp, Subgroup.range_subtype, I']
simp only [← MonoidHom.range_comp, MonoidHom.fst_comp_prod, MonoidHom.range_eq_top]
exact (MonoidHom.fst ..).subgroupMap_surjective I
have hI₂' : Surjective (Prod.snd ∘ I'.subtype) := by
simp only [← MonoidHom.coe_snd, ← MonoidHom.coe_comp, ← MonoidHom.range_eq_top,
MonoidHom.range_comp, Subgroup.range_subtype, I']
simp only [← MonoidHom.range_comp, MonoidHom.range_eq_top]
exact (MonoidHom.snd ..).subgroupMap_surjective I
have := normal_goursatFst hI₁'
have := normal_goursatSnd hI₂'
obtain ⟨e, he⟩ := goursat_surjective hI₁' hI₂'
refine ⟨I.map (MonoidHom.fst ..), I.map (MonoidHom.snd ..),
I'.goursatFst, I'.goursatSnd, inferInstance, inferInstance, e, ?_⟩
rw [← he]
simp only [MonoidHom.range_comp, Subgroup.range_subtype, I']
rw [comap_map_eq_self]
· ext ⟨g, h⟩
constructor
· intro hgh
simpa only [G', H', mem_map, MonoidHom.mem_range, MonoidHom.prod_apply, Subtype.exists,
Prod.exists, MonoidHom.coe_prodMap, coe_subtype, Prod.mk.injEq, Prod.map_apply,
MonoidHom.coe_snd, exists_eq_right, exists_and_right, exists_eq_right_right,
MonoidHom.coe_fst]
using ⟨⟨h, hgh⟩, ⟨g, hgh⟩, g, h, hgh, ⟨rfl, rfl⟩⟩
· simp only [G', H', mem_map, MonoidHom.mem_range, MonoidHom.prod_apply, Subtype.exists,
Prod.exists, MonoidHom.coe_prodMap, coe_subtype, Prod.mk.injEq, Prod.map_apply,
MonoidHom.coe_snd, exists_eq_right, exists_and_right, exists_eq_right_right,
MonoidHom.coe_fst, forall_exists_index, and_imp]
rintro h₁ hgh₁ g₁ hg₁h g₂ h₂ hg₂h₂ hP hQ
simp only [Subtype.ext_iff] at hP hQ
rwa [← hP, ← hQ]
· convert goursatFst_prod_goursatSnd_le (P.prod Q).range
ext ⟨g, h⟩
simp_rw [G', H', MonoidHom.mem_ker, MonoidHom.coe_prodMap, Prod.map_apply, Subgroup.mem_prod,
... | lemma | GroupTheory | [
"Mathlib.Algebra.Group.Graph",
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Goursat.lean | goursat | **Goursat's lemma** for an arbitrary subgroup.
If `I` is a subgroup of `G × H`, then there exist subgroups `G' ≤ G`, `H' ≤ H` and normal subgroups
`M ⊴ G'` and `N ⊴ H'` such that `M × N ≤ I` and the image of `I` in `G' ⧸ M × H' ⧸ N` is the graph
of an isomorphism `G' ⧸ M ≃ H' ⧸ N`. |
HNNExtension.con (G : Type*) [Group G] (A B : Subgroup G) (φ : A ≃* B) :
Con (G ∗ Multiplicative ℤ) :=
conGen (fun x y => ∃ (a : A),
x = inr (ofAdd 1) * inl (a : G) ∧
y = inl (φ a : G) * inr (ofAdd 1)) | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | HNNExtension.con | The relation we quotient the coproduct by to form an `HNNExtension`. |
HNNExtension (G : Type*) [Group G] (A B : Subgroup G) (φ : A ≃* B) : Type _ :=
(HNNExtension.con G A B φ).Quotient
variable {G : Type*} [Group G] {A B : Subgroup G} {φ : A ≃* B} {H : Type*}
[Group H] {M : Type*} [Monoid M] | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | HNNExtension | The HNN Extension of a group `G`, `HNNExtension G A B φ`. Given a group `G`, subgroups `A` and
`B` and an isomorphism `φ` of `A` and `B`, we adjoin a letter `t` to `G`, such that for
any `a ∈ A`, the conjugate of `of a` by `t` is `of (φ a)`, where `of` is the canonical
map from `G` into the `HNNExtension`. |
of : G →* HNNExtension G A B φ :=
(HNNExtension.con G A B φ).mk'.comp inl | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | of | The canonical embedding `G →* HNNExtension G A B φ` |
t : HNNExtension G A B φ :=
(HNNExtension.con G A B φ).mk'.comp inr (ofAdd 1) | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | t | The stable letter of the `HNNExtension` |
t_mul_of (a : A) :
t * (of (a : G) : HNNExtension G A B φ) = of (φ a : G) * t :=
(Con.eq _).2 <| ConGen.Rel.of _ _ <| ⟨a, by simp⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | t_mul_of | null |
of_mul_t (b : B) :
(of (b : G) : HNNExtension G A B φ) * t = t * of (φ.symm b : G) := by
rw [t_mul_of]; simp | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | of_mul_t | null |
equiv_eq_conj (a : A) :
(of (φ a : G) : HNNExtension G A B φ) = t * of (a : G) * t⁻¹ := by
rw [t_mul_of]; simp | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | equiv_eq_conj | null |
equiv_symm_eq_conj (b : B) :
(of (φ.symm b : G) : HNNExtension G A B φ) = t⁻¹ * of (b : G) * t := by
rw [mul_assoc, of_mul_t]; simp | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | equiv_symm_eq_conj | null |
inv_t_mul_of (b : B) :
t⁻¹ * (of (b : G) : HNNExtension G A B φ) = of (φ.symm b : G) * t⁻¹ := by
rw [equiv_symm_eq_conj]; simp | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | inv_t_mul_of | null |
of_mul_inv_t (a : A) :
(of (a : G) : HNNExtension G A B φ) * t⁻¹ = t⁻¹ * of (φ a : G) := by
rw [equiv_eq_conj]; simp [mul_assoc] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | of_mul_inv_t | null |
lift (f : G →* H) (x : H) (hx : ∀ a : A, x * f ↑a = f (φ a : G) * x) :
HNNExtension G A B φ →* H :=
Con.lift _ (Coprod.lift f (zpowersHom H x)) (Con.conGen_le <| by
rintro _ _ ⟨a, rfl, rfl⟩
simp [hx])
@[simp] | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | lift | Define a function `HNNExtension G A B φ →* H`, by defining it on `G` and `t` |
lift_t (f : G →* H) (x : H) (hx : ∀ a : A, x * f ↑a = f (φ a : G) * x) :
lift f x hx t = x := by
delta HNNExtension; simp [lift, t]
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | lift_t | null |
lift_of (f : G →* H) (x : H) (hx : ∀ a : A, x * f ↑a = f (φ a : G) * x) (g : G) :
lift f x hx (of g) = f g := by
delta HNNExtension; simp [lift, of]
@[ext high] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | lift_of | null |
hom_ext {f g : HNNExtension G A B φ →* M}
(hg : f.comp of = g.comp of) (ht : f t = g t) : f = g :=
(MonoidHom.cancel_right Con.mk'_surjective).mp <|
Coprod.hom_ext hg (MonoidHom.ext_mint ht)
@[elab_as_elim] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | hom_ext | null |
induction_on {motive : HNNExtension G A B φ → Prop}
(x : HNNExtension G A B φ) (of : ∀ g, motive (of g))
(t : motive t) (mul : ∀ x y, motive x → motive y → motive (x * y))
(inv : ∀ x, motive x → motive x⁻¹) : motive x := by
let S : Subgroup (HNNExtension G A B φ) :=
{ carrier := setOf motive
one_mem' := by simpa using of 1
mul_mem' := mul _ _
inv_mem' := inv _ }
let f : HNNExtension G A B φ →* S :=
lift (HNNExtension.of.codRestrict S of)
⟨HNNExtension.t, t⟩ (by intro a; ext; simp [equiv_eq_conj, mul_assoc])
have hf : S.subtype.comp f = MonoidHom.id _ :=
hom_ext (by ext; simp [f]) (by simp [f])
change motive (MonoidHom.id _ x)
rw [← hf]
exact (f x).2
variable (A B φ) | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | induction_on | null |
toSubgroup (u : ℤˣ) : Subgroup G :=
if u = 1 then A else B
@[simp] | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | toSubgroup | To avoid duplicating code, we define `toSubgroup A B u` and `toSubgroupEquiv u`
where `u : ℤˣ` is `1` or `-1`. `toSubgroup A B u` is `A` when `u = 1` and `B` when `u = -1`,
and `toSubgroupEquiv` is `φ` when `u = 1` and `φ⁻¹` when `u = -1`. `toSubgroup u` is the subgroup
such that for any `a ∈ toSubgroup u`, `t ^ (u : ℤ) * a = toSubgroupEquiv a * t ^ (u : ℤ)`. |
toSubgroup_one : toSubgroup A B 1 = A := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | toSubgroup_one | null |
toSubgroup_neg_one : toSubgroup A B (-1) = B := rfl
variable {A B} | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | toSubgroup_neg_one | null |
toSubgroupEquiv (u : ℤˣ) : toSubgroup A B u ≃* toSubgroup A B (-u) :=
if hu : u = 1 then hu ▸ φ else by
convert φ.symm <;>
cases Int.units_eq_one_or u <;> simp_all
@[simp] | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | toSubgroupEquiv | To avoid duplicating code, we define `toSubgroup A B u` and `toSubgroupEquiv u`
where `u : ℤˣ` is `1` or `-1`. `toSubgroup A B u` is `A` when `u = 1` and `B` when `u = -1`,
and `toSubgroupEquiv` is the group isomorphism from `toSubgroup A B u` to `toSubgroup A B (-u)`.
It is defined to be `φ` when `u = 1` and `φ⁻¹` when `u = -1`. |
toSubgroupEquiv_one : toSubgroupEquiv φ 1 = φ := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | toSubgroupEquiv_one | null |
toSubgroupEquiv_neg_one : toSubgroupEquiv φ (-1) = φ.symm := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | toSubgroupEquiv_neg_one | null |
toSubgroupEquiv_neg_apply (u : ℤˣ) (a : toSubgroup A B u) :
(toSubgroupEquiv φ (-u) (toSubgroupEquiv φ u a) : G) = a := by
rcases Int.units_eq_one_or u with rfl | rfl
· simp [toSubgroup]
· simp only [toSubgroup_neg_one, toSubgroupEquiv_neg_one, SetLike.coe_eq_coe]
exact φ.apply_symm_apply a | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | toSubgroupEquiv_neg_apply | null |
TransversalPair : Type _ where
/-- The transversal of each subgroup -/
set : ℤˣ → Set G
/-- We have exactly one element of each coset of the subgroup -/
compl : ∀ u, IsComplement (toSubgroup A B u : Subgroup G) (set u) | structure | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | TransversalPair | To put word in the HNN Extension into a normal form, we must choose an element of each right
coset of both `A` and `B`, such that the chosen element of the subgroup itself is `1`. |
TransversalPair.nonempty : Nonempty (TransversalPair G A B) := by
choose t ht using fun u ↦ (toSubgroup A B u).exists_isComplement_right 1
exact ⟨⟨t, fun i ↦ (ht i).1⟩⟩ | instance | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | TransversalPair.nonempty | null |
ReducedWord : Type _ where
/-- Every `ReducedWord` is the product of an element of the group and a word made up
of letters each of which is in the transversal. `head` is that element of the base group. -/
head : G
/-- The list of pairs `(ℤˣ × G)`, where each pair `(u, g)` represents the element `t^u * g` of
`HNNExtension G A B φ` -/
toList : List (ℤˣ × G)
/-- There are no sequences of the form `t^u * g * t^-u` where `g ∈ toSubgroup A B u` -/
chain : toList.IsChain (fun a b => a.2 ∈ toSubgroup A B a.1 → a.1 = b.1) | structure | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | ReducedWord | A reduced word is a `head`, which is an element of `G`, followed by the product list of pairs.
There should also be no sequences of the form `t^u * g * t^-u`, where `g` is in
`toSubgroup A B u` This is a less strict condition than required for `NormalWord`. |
@[simps]
ReducedWord.empty : ReducedWord G A B :=
{ head := 1
toList := []
chain := List.isChain_nil }
variable {G A B} | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | ReducedWord.empty | The empty reduced word. |
ReducedWord.prod : ReducedWord G A B → HNNExtension G A B φ :=
fun w => of w.head * (w.toList.map (fun x => t ^ (x.1 : ℤ) * of x.2)).prod | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | ReducedWord.prod | The product of a `ReducedWord` as an element of the `HNNExtension` |
_root_.HNNExtension.NormalWord (d : TransversalPair G A B) : Type _
extends ReducedWord G A B where
/-- Every element `g : G` in the list is the chosen element of its coset -/
mem_set : ∀ (u : ℤˣ) (g : G), (u, g) ∈ toList → g ∈ d.set u
variable {d : TransversalPair G A B}
@[ext] | structure | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | _root_.HNNExtension.NormalWord | Given a `TransversalPair`, we can make a normal form for words in the `HNNExtension G A B φ`.
The normal form is a `head`, which is an element of `G`, followed by the product list of pairs,
`t ^ u * g`, where `u` is `1` or `-1` and `g` is the chosen element of its right coset of
`toSubgroup A B u`. There should also be no sequences of the form `t^u * g * t^-u`
where `g ∈ toSubgroup A B u` |
ext {w w' : NormalWord d}
(h1 : w.head = w'.head) (h2 : w.toList = w'.toList) : w = w' := by
rcases w with ⟨⟨⟩, _⟩; cases w'; simp_all | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | ext | null |
@[simps]
empty : NormalWord d :=
{ head := 1
toList := []
mem_set := by simp
chain := List.isChain_nil } | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | empty | The empty word |
@[simps]
ofGroup (g : G) : NormalWord d :=
{ head := g
toList := []
mem_set := by simp
chain := List.isChain_nil } | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | ofGroup | The `NormalWord` representing an element `g` of the group `G`, which is just the element `g`
itself. |
group_smul_def (g : G) (w : NormalWord d) :
g • w = { w with head := g * w.head } := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | group_smul_def | null |
group_smul_head (g : G) (w : NormalWord d) : (g • w).head = g * w.head := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | group_smul_head | null |
group_smul_toList (g : G) (w : NormalWord d) : (g • w).toList = w.toList := rfl | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | group_smul_toList | null |
@[simps]
cons (g : G) (u : ℤˣ) (w : NormalWord d) (h1 : w.head ∈ d.set u)
(h2 : ∀ u' ∈ Option.map Prod.fst w.toList.head?, w.head ∈ toSubgroup A B u → u = u') :
NormalWord d :=
{ head := g,
toList := (u, w.head) :: w.toList,
mem_set := by
intro u' g' h'
simp only [List.mem_cons, Prod.mk.injEq] at h'
rcases h' with ⟨rfl, rfl⟩ | h'
· exact h1
· exact w.mem_set _ _ h'
chain := by
refine List.isChain_cons'.2 ⟨?_, w.chain⟩
rintro ⟨u', g'⟩ hu' hw1
exact h2 _ (by simp_all) hw1 } | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | cons | A constructor to append an element `g` of `G` and `u : ℤˣ` to a word `w` with sufficient
hypotheses that no normalization or cancellation need take place for the result to be in normal form |
@[elab_as_elim]
consRecOn {motive : NormalWord d → Sort*} (w : NormalWord d)
(ofGroup : ∀ g, motive (ofGroup g))
(cons : ∀ (g : G) (u : ℤˣ) (w : NormalWord d) (h1 : w.head ∈ d.set u)
(h2 : ∀ u' ∈ Option.map Prod.fst w.toList.head?,
w.head ∈ toSubgroup A B u → u = u'),
motive w → motive (cons g u w h1 h2)) : motive w := by
rcases w with ⟨⟨g, l, chain⟩, mem_set⟩
induction l generalizing g with
| nil => exact ofGroup _
| cons a l ih =>
exact cons g a.1
{ head := a.2
toList := l
mem_set := fun _ _ h => mem_set _ _ (List.mem_cons_of_mem _ h),
chain := (List.isChain_cons'.1 chain).2 }
(mem_set a.1 a.2 List.mem_cons_self)
(by simpa using (List.isChain_cons'.1 chain).1)
(ih _ _ _)
@[simp] | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | consRecOn | A recursor to induct on a `NormalWord`, by proving the property is preserved under `cons` |
consRecOn_ofGroup {motive : NormalWord d → Sort*}
(g : G) (ofGroup : ∀ g, motive (ofGroup g))
(cons : ∀ (g : G) (u : ℤˣ) (w : NormalWord d) (h1 : w.head ∈ d.set u)
(h2 : ∀ u' ∈ Option.map Prod.fst w.toList.head?, w.head
∈ toSubgroup A B u → u = u'),
motive w → motive (cons g u w h1 h2)) :
consRecOn (.ofGroup g) ofGroup cons = ofGroup g := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | consRecOn_ofGroup | null |
consRecOn_cons {motive : NormalWord d → Sort*}
(g : G) (u : ℤˣ) (w : NormalWord d) (h1 : w.head ∈ d.set u)
(h2 : ∀ u' ∈ Option.map Prod.fst w.toList.head?, w.head ∈ toSubgroup A B u → u = u')
(ofGroup : ∀ g, motive (ofGroup g))
(cons : ∀ (g : G) (u : ℤˣ) (w : NormalWord d) (h1 : w.head ∈ d.set u)
(h2 : ∀ u' ∈ Option.map Prod.fst w.toList.head?,
w.head ∈ toSubgroup A B u → u = u'),
motive w → motive (cons g u w h1 h2)) :
consRecOn (.cons g u w h1 h2) ofGroup cons = cons g u w h1 h2
(consRecOn w ofGroup cons) := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | consRecOn_cons | null |
smul_cons (g₁ g₂ : G) (u : ℤˣ) (w : NormalWord d) (h1 : w.head ∈ d.set u)
(h2 : ∀ u' ∈ Option.map Prod.fst w.toList.head?, w.head ∈ toSubgroup A B u → u = u') :
g₁ • cons g₂ u w h1 h2 = cons (g₁ * g₂) u w h1 h2 :=
rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | smul_cons | null |
smul_ofGroup (g₁ g₂ : G) :
g₁ • (ofGroup g₂ : NormalWord d) = ofGroup (g₁ * g₂) := rfl
variable (d) | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | smul_ofGroup | null |
noncomputable unitsSMulGroup (u : ℤˣ) (g : G) :
(toSubgroup A B (-u)) × d.set u :=
let g' := (d.compl u).equiv g
(toSubgroupEquiv φ u g'.1, g'.2) | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | unitsSMulGroup | The action of `t^u` on `ofGroup g`. The normal form will be
`a * t^u * g'` where `a ∈ toSubgroup A B (-u)` |
unitsSMulGroup_snd (u : ℤˣ) (g : G) :
(unitsSMulGroup φ d u g).2 = ((d.compl u).equiv g).2 := by
rcases Int.units_eq_one_or u with rfl | rfl <;> rfl
variable {d} | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | unitsSMulGroup_snd | null |
Cancels (u : ℤˣ) (w : NormalWord d) : Prop :=
(w.head ∈ (toSubgroup A B u : Subgroup G)) ∧ w.toList.head?.map Prod.fst = some (-u) | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | Cancels | `Cancels u w` is a predicate expressing whether `t^u` cancels with some occurrence
of `t^-u` when we multiply `t^u` by `w`. |
unitsSMulWithCancel (u : ℤˣ) (w : NormalWord d) : Cancels u w → NormalWord d :=
consRecOn w
(by simp [Cancels, ofGroup]; tauto)
(fun g _ w _ _ _ can =>
(toSubgroupEquiv φ u ⟨g, can.1⟩ : G) • w) | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | unitsSMulWithCancel | Multiplying `t^u` by `w` in the special case where cancellation happens |
noncomputable unitsSMul (u : ℤˣ) (w : NormalWord d) : NormalWord d :=
letI := Classical.dec
if h : Cancels u w
then unitsSMulWithCancel φ u w h
else let g' := unitsSMulGroup φ d u w.head
cons g'.1 u ((g'.2 * w.head⁻¹ : G) • w)
(by simp)
(by
simp only [g', group_smul_toList, Option.mem_def, Option.map_eq_some_iff, Prod.exists,
exists_and_right, exists_eq_right, group_smul_head, inv_mul_cancel_right,
forall_exists_index, unitsSMulGroup]
simp only [Cancels, Option.map_eq_some_iff, Prod.exists, exists_and_right, exists_eq_right,
not_and, not_exists] at h
intro u' x hx hmem
have : w.head ∈ toSubgroup A B u := by
have := (d.compl u).rightCosetEquivalence_equiv_snd w.head
rw [RightCosetEquivalence, rightCoset_eq_iff, mul_mem_cancel_left hmem] at this
simp_all
have := h this x
simp_all [Int.units_ne_iff_eq_neg]) | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | unitsSMul | Multiplying `t^u` by a `NormalWord`, `w` and putting the result in normal form. |
not_cancels_of_cons_hyp (u : ℤˣ) (w : NormalWord d)
(h2 : ∀ u' ∈ Option.map Prod.fst w.toList.head?,
w.head ∈ toSubgroup A B u → u = u') :
¬ Cancels u w := by
simp only [Cancels, Option.map_eq_some_iff, Prod.exists,
exists_and_right, exists_eq_right, not_and, not_exists]
intro hw x hx
rw [hx] at h2
simpa using h2 (-u) rfl hw | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | not_cancels_of_cons_hyp | A condition for not cancelling whose hypotheses are the same as those of the `cons` function. |
unitsSMul_cancels_iff (u : ℤˣ) (w : NormalWord d) :
Cancels (-u) (unitsSMul φ u w) ↔ ¬ Cancels u w := by
by_cases h : Cancels u w
· simp only [unitsSMul, h, dite_true, not_true_eq_false, iff_false]
induction w using consRecOn with
| ofGroup => simp [Cancels, unitsSMulWithCancel]
| cons g u' w h1 h2 _ =>
intro hc
apply not_cancels_of_cons_hyp _ _ h2
simp only [Cancels, cons_head, cons_toList, List.head?_cons,
Option.map_some, Option.some.injEq] at h
cases h.2
simpa [Cancels, unitsSMulWithCancel,
Subgroup.mul_mem_cancel_left] using hc
· simp only [unitsSMul, dif_neg h]
simpa [Cancels] using h | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | unitsSMul_cancels_iff | null |
unitsSMul_neg (u : ℤˣ) (w : NormalWord d) :
unitsSMul φ (-u) (unitsSMul φ u w) = w := by
rw [unitsSMul]
split_ifs with hcan
· have hncan : ¬ Cancels u w := (unitsSMul_cancels_iff _ _ _).1 hcan
unfold unitsSMul
simp only [dif_neg hncan]
simp [unitsSMulWithCancel, unitsSMulGroup, (d.compl u).equiv_snd_eq_inv_mul,
-SetLike.coe_sort_coe]
· have hcan2 : Cancels u w := not_not.1 (mt (unitsSMul_cancels_iff _ _ _).2 hcan)
unfold unitsSMul at hcan ⊢
simp only [dif_pos hcan2] at hcan ⊢
cases w using consRecOn with
| ofGroup => simp [Cancels] at hcan2
| cons g u' w h1 h2 ih =>
clear ih
simp only [unitsSMulGroup, SetLike.coe_sort_coe, unitsSMulWithCancel, id_eq, consRecOn_cons,
group_smul_head,
mul_inv_rev]
cases hcan2.2
have : ((d.compl (-u)).equiv w.head).1 = 1 :=
(d.compl (-u)).equiv_fst_eq_one_of_mem_of_one_mem _ h1
apply NormalWord.ext
· -- This used to `simp [this]` before https://github.com/leanprover/lean4/pull/2644
dsimp
conv_lhs => erw [IsComplement.equiv_mul_left]
rw [map_mul, Submonoid.coe_mul, toSubgroupEquiv_neg_apply, this]
simp
· -- The next two lines were not needed before https://github.com/leanprover/lean4/pull/2644
dsimp
conv_lhs => erw [IsComplement.equiv_mul_left]
simp [Units.ext_iff, (d.compl (-u)).equiv_snd_eq_inv_mul, this,
-SetLike.coe_sort_coe] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | unitsSMul_neg | null |
@[simps]
noncomputable unitsSMulEquiv : NormalWord d ≃ NormalWord d :=
{ toFun := unitsSMul φ 1
invFun := unitsSMul φ (-1),
left_inv := fun _ => by rw [unitsSMul_neg]
right_inv := fun w => by convert unitsSMul_neg _ _ w; simp } | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | unitsSMulEquiv | the equivalence given by multiplication on the left by `t` |
unitsSMul_one_group_smul (g : A) (w : NormalWord d) :
unitsSMul φ 1 ((g : G) • w) = (φ g : G) • (unitsSMul φ 1 w) := by
unfold unitsSMul
have : Cancels 1 ((g : G) • w) ↔ Cancels 1 w := by
simp [Cancels, Subgroup.mul_mem_cancel_left]
by_cases hcan : Cancels 1 w
· simp only [unitsSMulWithCancel, toSubgroup_one, id_eq, toSubgroup_neg_one, toSubgroupEquiv_one,
group_smul_head, mul_inv_rev, dif_pos (this.2 hcan), dif_pos hcan]
cases w using consRecOn
· simp [Cancels] at hcan
· simp only [smul_cons, consRecOn_cons]
rw [← mul_smul, ← Subgroup.coe_mul, ← map_mul φ]
rfl
· rw [dif_neg (mt this.1 hcan), dif_neg hcan]
simp only [toSubgroup_neg_one, unitsSMulGroup, toSubgroup_one, toSubgroupEquiv_one,
SetLike.coe_sort_coe, group_smul_head, mul_inv_rev, ← mul_smul, mul_assoc, inv_mul_cancel,
mul_one, smul_cons]
congr 1
· conv_lhs => erw [IsComplement.equiv_mul_left]
simp_rw [toSubgroup_one]
simp only [SetLike.coe_sort_coe, map_mul, Subgroup.coe_mul]
conv_lhs => erw [IsComplement.equiv_mul_left]
rfl | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | unitsSMul_one_group_smul | null |
@[simp]
prod_group_smul (g : G) (w : NormalWord d) :
(g • w).prod φ = of g * (w.prod φ) := by
simp [ReducedWord.prod, mul_assoc] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | prod_group_smul | null |
of_smul_eq_smul (g : G) (w : NormalWord d) :
(of g : HNNExtension G A B φ) • w = g • w := by
simp [instHSMul, SMul.smul, MulAction.toEndHom] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | of_smul_eq_smul | null |
t_smul_eq_unitsSMul (w : NormalWord d) :
(t : HNNExtension G A B φ) • w = unitsSMul φ 1 w := by
simp [instHSMul, SMul.smul, MulAction.toEndHom] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | t_smul_eq_unitsSMul | null |
t_pow_smul_eq_unitsSMul (u : ℤˣ) (w : NormalWord d) :
(t ^ (u : ℤ) : HNNExtension G A B φ) • w = unitsSMul φ u w := by
rcases Int.units_eq_one_or u with (rfl | rfl) <;>
simp [instHSMul, SMul.smul, MulAction.toEndHom, Equiv.Perm.inv_def]
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | t_pow_smul_eq_unitsSMul | null |
prod_cons (g : G) (u : ℤˣ) (w : NormalWord d) (h1 : w.head ∈ d.set u)
(h2 : ∀ u' ∈ Option.map Prod.fst w.toList.head?,
w.head ∈ toSubgroup A B u → u = u') :
(cons g u w h1 h2).prod φ = of g * (t ^ (u : ℤ) * w.prod φ) := by
simp [ReducedWord.prod, cons, mul_assoc] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | prod_cons | null |
prod_unitsSMul (u : ℤˣ) (w : NormalWord d) :
(unitsSMul φ u w).prod φ = (t^(u : ℤ) * w.prod φ : HNNExtension G A B φ) := by
rw [unitsSMul]
split_ifs with hcan
· cases w using consRecOn
· simp [Cancels] at hcan
· cases hcan.2
simp only [unitsSMulWithCancel, id_eq, consRecOn_cons, prod_group_smul, prod_cons, zpow_neg]
rcases Int.units_eq_one_or u with (rfl | rfl)
· simp [equiv_eq_conj, mul_assoc]
· -- Before https://github.com/leanprover/lean4/pull/2644, this proof was just
simp only [toSubgroup_neg_one, toSubgroupEquiv_neg_one, Units.val_neg, Units.val_one,
Int.reduceNeg, zpow_neg, zpow_one, inv_inv]
erw [equiv_symm_eq_conj]
simp [mul_assoc]
· simp only [unitsSMulGroup, SetLike.coe_sort_coe, prod_cons, prod_group_smul, map_mul, map_inv]
rcases Int.units_eq_one_or u with (rfl | rfl)
· -- Before https://github.com/leanprover/lean4/pull/2644, this proof was just
simp only [toSubgroup_neg_one, toSubgroup_one, toSubgroupEquiv_one, equiv_eq_conj, mul_assoc,
Units.val_one, zpow_one, inv_mul_cancel_left, mul_right_inj]
erw [(d.compl 1).equiv_snd_eq_inv_mul]
simp [mul_assoc]
· -- Before https://github.com/leanprover/lean4/pull/2644, this proof was just
simp only [toSubgroup_neg_one, toSubgroupEquiv_neg_one, Units.val_neg, Units.val_one,
Int.reduceNeg, zpow_neg, zpow_one, mul_assoc]
erw [equiv_symm_eq_conj, (d.compl (-1)).equiv_snd_eq_inv_mul]
simp [mul_assoc]
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | prod_unitsSMul | null |
prod_empty : (empty : NormalWord d).prod φ = 1 := by
simp [ReducedWord.prod]
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | prod_empty | null |
prod_smul (g : HNNExtension G A B φ) (w : NormalWord d) :
(g • w).prod φ = g * w.prod φ := by
induction g using induction_on generalizing w with
| of => simp [of_smul_eq_smul]
| t => simp [t_smul_eq_unitsSMul, prod_unitsSMul]
| mul => simp_all [mul_smul, mul_assoc]
| inv x ih =>
rw [← mul_right_inj x, ← ih]
simp
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | prod_smul | null |
prod_smul_empty (w : NormalWord d) :
(w.prod φ) • empty = w := by
induction w using consRecOn with
| ofGroup => simp [ofGroup, ReducedWord.prod, of_smul_eq_smul, group_smul_def]
| cons g u w h1 h2 ih =>
rw [prod_cons, ← mul_assoc, mul_smul, ih, mul_smul, t_pow_smul_eq_unitsSMul,
of_smul_eq_smul, unitsSMul]
rw [dif_neg (not_cancels_of_cons_hyp u w h2)]
simp only [unitsSMulGroup, (d.compl _).equiv_fst_eq_one_of_mem_of_one_mem (one_mem _) h1,
smul_cons]
ext <;> simp [-SetLike.coe_sort_coe]
rw [(d.compl _).equiv_snd_eq_inv_mul,
(d.compl _).equiv_fst_eq_one_of_mem_of_one_mem (one_mem _) h1]
simp
variable (d) | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | prod_smul_empty | null |
noncomputable equiv : HNNExtension G A B φ ≃ NormalWord d :=
{ toFun := fun g => g • empty,
invFun := fun w => w.prod φ,
left_inv := fun g => by simp [prod_smul]
right_inv := fun w => by simp } | def | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | equiv | The equivalence between elements of the HNN extension and words in normal form. |
prod_injective : Injective
(fun w => w.prod φ : NormalWord d → HNNExtension G A B φ) :=
(equiv φ d).symm.injective | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | prod_injective | null |
of_injective : Function.Injective (of : G → HNNExtension G A B φ) := by
rcases TransversalPair.nonempty G A B with ⟨d⟩
refine Function.Injective.of_comp
(f := ((· • ·) : HNNExtension G A B φ → NormalWord d → NormalWord d)) ?_
intro _ _ h
exact eq_of_smul_eq_smul (fun w : NormalWord d =>
by simp_all [funext_iff, of_smul_eq_smul]) | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | of_injective | null |
exists_normalWord_prod_eq
(d : TransversalPair G A B) (w : ReducedWord G A B) :
∃ w' : NormalWord d, w'.prod φ = w.prod φ ∧
w'.toList.map Prod.fst = w.toList.map Prod.fst ∧
∀ u ∈ w.toList.head?.map Prod.fst,
w'.head⁻¹ * w.head ∈ toSubgroup A B (-u) := by
suffices ∀ w : ReducedWord G A B,
w.head = 1 → ∃ w' : NormalWord d, w'.prod φ = w.prod φ ∧
w'.toList.map Prod.fst = w.toList.map Prod.fst ∧
∀ u ∈ w.toList.head?.map Prod.fst,
w'.head ∈ toSubgroup A B (-u) by
by_cases hw1 : w.head = 1
· simp only [hw1, inv_mem_iff, mul_one]
exact this w hw1
· rcases this ⟨1, w.toList, w.chain⟩ rfl with ⟨w', hw'⟩
exact ⟨w.head • w', by
simpa [ReducedWord.prod, mul_assoc] using hw'⟩
intro w hw1
rcases w with ⟨g, l, chain⟩
dsimp at hw1; subst hw1
induction l with
| nil =>
exact
⟨{ head := 1
toList := []
mem_set := by simp
chain := List.isChain_nil }, by simp⟩
| cons a l ih =>
rcases ih (List.isChain_cons'.1 chain).2 with ⟨w', hw'1, hw'2, hw'3⟩
clear ih
refine ⟨(t^(a.1 : ℤ) * of a.2 : HNNExtension G A B φ) • w', ?_, ?_⟩
· rw [prod_smul, hw'1]
simp [ReducedWord.prod]
· have : ¬ Cancels a.1 (a.2 • w') := by
simp only [Cancels, group_smul_head, group_smul_toList, Option.map_eq_some_iff,
Prod.exists, exists_and_right, exists_eq_right, not_and, not_exists]
intro hS x hx
have hx' := congr_arg (Option.map Prod.fst) hx
rw [← List.head?_map, hw'2, List.head?_map, Option.map_some] at hx'
have : w'.head ∈ toSubgroup A B a.fst := by
simpa using hw'3 _ hx'
rw [mul_mem_cancel_right this] at hS
have : a.fst = -a.fst := by
have hl : l ≠ [] := by rintro rfl; simp_all
have : a.fst = (l.head hl).fst := (List.isChain_cons'.1 chain).1 (l.head hl)
(List.head?_eq_head _) hS
rwa [List.head?_eq_head hl, Option.map_some, ← this, Option.some_inj] at hx'
simp at this
rw [List.map_cons, mul_smul, of_smul_eq_smul, NormalWord.group_smul_def,
t_pow_smul_eq_unitsSMul, unitsSMul]
erw [dif_neg this]
... | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | exists_normalWord_prod_eq | null |
map_fst_eq_and_of_prod_eq {w₁ w₂ : ReducedWord G A B}
(hprod : w₁.prod φ = w₂.prod φ) :
w₁.toList.map Prod.fst = w₂.toList.map Prod.fst ∧
∀ u ∈ w₁.toList.head?.map Prod.fst,
w₁.head⁻¹ * w₂.head ∈ toSubgroup A B (-u) := by
rcases TransversalPair.nonempty G A B with ⟨d⟩
rcases exists_normalWord_prod_eq φ d w₁ with ⟨w₁', hw₁'1, hw₁'2, hw₁'3⟩
rcases exists_normalWord_prod_eq φ d w₂ with ⟨w₂', hw₂'1, hw₂'2, hw₂'3⟩
have : w₁' = w₂' :=
NormalWord.prod_injective φ d (by dsimp only; rw [hw₁'1, hw₂'1, hprod])
subst this
refine ⟨by rw [← hw₁'2, hw₂'2], ?_⟩
simp only [← leftCoset_eq_iff] at *
intro u hu
rw [← hw₁'3 _ hu, ← hw₂'3 _]
rwa [← List.head?_map, ← hw₂'2, hw₁'2, List.head?_map] | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | map_fst_eq_and_of_prod_eq | Two reduced words representing the same element of the `HNNExtension G A B φ` have the same
length corresponding list, with the same pattern of occurrences of `t^1` and `t^(-1)`,
and also the `head` is in the same left coset of `toSubgroup A B (-u)`, where `u : ℤˣ`
is the exponent of the first occurrence of `t` in the word. |
toList_eq_nil_of_mem_of_range (w : ReducedWord G A B)
(hw : w.prod φ ∈ (of.range : Subgroup (HNNExtension G A B φ))) :
w.toList = [] := by
rcases hw with ⟨g, hg⟩
let w' : ReducedWord G A B := { ReducedWord.empty G A B with head := g }
have : w.prod φ = w'.prod φ := by simp [w', ReducedWord.prod, hg]
simpa [w'] using (map_fst_eq_and_of_prod_eq φ this).1 | theorem | GroupTheory | [
"Mathlib.Algebra.Ring.CharZero",
"Mathlib.Algebra.Ring.Int.Units",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/HNNExtension.lean | toList_eq_nil_of_mem_of_range | **Britton's Lemma**. Any reduced word whose product is an element of `G`, has no
occurrences of `t`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.