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... | 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.induc... | 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]
· ... | 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 ↦ ?_) ?_
· re... | 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_... | 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]
m... | 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 ... | 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... | 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]
constructo... | 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... | 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'`... |
@[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 :
∃... | 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... | 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 : ℤ... |
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 `φ⁻¹` whe... |
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
`... | 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... |
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.in... | 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... | 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)) :
... | 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)
... | 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_de... | 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... | 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 ... | 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_s... | 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, toSubgrou... | 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,... | 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,... | 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, uni... | 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 [fun... | 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,
... | 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_pro... | 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 ... |
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]
sim... | 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.