Subgroups #
This file defines multiplicative and additive subgroups as an extension of submonoids, in a bundled
form (unbundled subgroups are in Deprecated/Subgroups.lean
).
We prove subgroups of a group form a complete lattice, and results about images and preimages of subgroups under group homomorphisms. The bundled subgroups use bundled monoid homomorphisms.
There are also theorems about the subgroups generated by an element or a subset of a group, defined both inductively and as the infimum of the set of subgroups containing a given element/subset.
Special thanks goes to Amelia Livingston and Yury Kudryashov for their help and inspiration.
Main definitions #
Notation used here:
G N
areGroup
sA
is anAddGroup
H K
areSubgroup
s ofG
orAddSubgroup
s ofA
x
is an element of typeG
or typeA
f g : N →* G
are group homomorphismss k
are sets of elements of typeG
Definitions in the file:
Subgroup G
: the type of subgroups of a groupG
AddSubgroup A
: the type of subgroups of an additive groupA
CompleteLattice (Subgroup G)
: the subgroups ofG
form a complete latticeSubgroup.closure k
: the minimal subgroup that includes the setk
Subgroup.subtype
: the natural group homomorphism from a subgroup of groupG
toG
Subgroup.gi
:closure
forms a Galois insertion with the coercion to setSubgroup.comap H f
: the preimage of a subgroupH
along the group homomorphismf
is also a subgroupSubgroup.map f H
: the image of a subgroupH
along the group homomorphismf
is also a subgroupSubgroup.prod H K
: the product of subgroupsH
,K
of groupsG
,N
respectively,H × K
is a subgroup ofG × N
MonoidHom.range f
: the range of the group homomorphismf
is a subgroupMonoidHom.ker f
: the kernel of a group homomorphismf
is the subgroup of elementsx : G
such thatf x = 1
MonoidHom.eq_locus f g
: given group homomorphismsf
,g
, the elements ofG
such thatf x = g x
form a subgroup ofG
Implementation notes #
Subgroup inclusion is denoted ≤
rather than ⊆
, although ∈
is defined as
membership of a subgroup's underlying set.
Tags #
subgroup, subgroups
s
is closed under inverses
s
is closed under negation
SubgroupClass S G
states S
is a type of subsets s ⊆ G
that are subgroups of G
.
Instances
AddSubgroupClass S G
states S
is a type of subsets s ⊆ G
that are
additive subgroups of G
.
Instances
Equations
- ⋯ = ⋯
Instances For
A subgroup of a group inherits an inverse.
Alias of InvMemClass.coe_inv
.
An additive subgroup of an AddGroup
inherits a subtraction.
A subgroup of a group inherits a division
An additive subgroup of an AddGroup
inherits an integer scaling.
A subgroup of a group inherits an integer power.
An additive subgroup of an AddGroup
inherits an AddGroup
structure.
Equations
- AddSubgroupClass.toAddGroup H = Function.Injective.addGroup (fun (a : ↥H) => ↑a) ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯
A subgroup of a group inherits a group structure.
Equations
- SubgroupClass.toGroup H = Function.Injective.group (fun (a : ↥H) => ↑a) ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯
An additive subgroup of an AddCommGroup
is an AddCommGroup
.
Equations
- AddSubgroupClass.toAddCommGroup H = Function.Injective.addCommGroup (fun (a : ↥H) => ↑a) ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯
A subgroup of a CommGroup
is a CommGroup
.
Equations
- SubgroupClass.toCommGroup H = Function.Injective.commGroup (fun (a : ↥H) => ↑a) ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯
The natural group hom from an additive subgroup of AddGroup
G
to G
.
Equations
- ↑H = { toFun := Subtype.val, map_zero' := ⋯, map_add' := ⋯ }
Instances For
The natural group hom from a subgroup of group G
to G
.
Equations
- ↑H = { toFun := Subtype.val, map_one' := ⋯, map_mul' := ⋯ }
Instances For
The inclusion homomorphism from an additive subgroup H
contained in K
to K
.
Equations
- AddSubgroupClass.inclusion h = AddMonoidHom.mk' (fun (x : ↥H) => ⟨↑x, ⋯⟩) ⋯
Instances For
The inclusion homomorphism from a subgroup H
contained in K
to K
.
Equations
- SubgroupClass.inclusion h = MonoidHom.mk' (fun (x : ↥H) => ⟨↑x, ⋯⟩) ⋯
Instances For
A subgroup of a group G
is a subset containing 1, closed under multiplication
and closed under multiplicative inverse.
Instances For
An additive subgroup of an additive group G
is a subset containing 0, closed
under addition and additive inverse.
Instances For
G
is closed under negation
Equations
- AddSubgroup.instSetLike = { coe := fun (s : AddSubgroup G) => s.carrier, coe_injective' := ⋯ }
Equations
- ⋯ = ⋯
Equations
- ⋯ = ⋯
Conversion to/from Additive
/Multiplicative
#
Subgroups of a group G
are isomorphic to additive subgroups of Additive G
.
Equations
- One or more equations did not get rendered due to their size.
Instances For
Additive subgroups of an additive group A
are isomorphic to subgroups of Multiplicative A
.
Equations
- One or more equations did not get rendered due to their size.
Instances For
Subgroups of an additive group Multiplicative A
are isomorphic to additive subgroups of A
.
Equations
- Subgroup.toAddSubgroup' = AddSubgroup.toSubgroup.symm
Instances For
Copy of an additive subgroup with a new carrier
equal to the old one.
Useful to fix definitional equalities
Equations
- K.copy s hs = { carrier := s, add_mem' := ⋯, zero_mem' := ⋯, neg_mem' := ⋯ }
Instances For
Two AddSubgroup
s are equal if they have the same elements.
An AddSubgroup
contains the group's 0.
An AddSubgroup
is closed under addition.
An AddSubgroup
is closed under inverse.
An AddSubgroup
is closed under subtraction.
Construct a subgroup from a nonempty set that is closed under subtraction
Equations
- AddSubgroup.ofSub s hsn hs = let_fun one_mem := ⋯; let_fun inv_mem := ⋯; { carrier := s, add_mem' := ⋯, zero_mem' := one_mem, neg_mem' := ⋯ }
Instances For
Construct a subgroup from a nonempty set that is closed under division.
Equations
- Subgroup.ofDiv s hsn hs = let_fun one_mem := ⋯; let_fun inv_mem := ⋯; { carrier := s, mul_mem' := ⋯, one_mem' := one_mem, inv_mem' := ⋯ }
Instances For
An AddSubgroup
of an AddGroup
inherits an addition.
Equations
- H.add = H.add
An AddSubgroup
of an AddGroup
inherits a zero.
Equations
- H.zero = H.zero
An AddSubgroup
of an AddGroup
inherits an inverse.
An AddSubgroup
of an AddGroup
inherits a subtraction.
An AddSubgroup
of an AddGroup
inherits a natural scaling.
An AddSubgroup
of an AddGroup
inherits an integer scaling.
An AddSubgroup
of an AddGroup
inherits an AddGroup
structure.
Equations
- H.toAddGroup = Function.Injective.addGroup (fun (a : ↥H) => ↑a) ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯
A subgroup of a group inherits a group structure.
Equations
- H.toGroup = Function.Injective.group (fun (a : ↥H) => ↑a) ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯
An AddSubgroup
of an AddCommGroup
is an AddCommGroup
.
Equations
- H.toAddCommGroup = Function.Injective.addCommGroup (fun (a : ↥H) => ↑a) ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯
A subgroup of a CommGroup
is a CommGroup
.
Equations
- H.toCommGroup = Function.Injective.commGroup (fun (a : ↥H) => ↑a) ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯
The natural group hom from an AddSubgroup
of AddGroup
G
to G
.
Equations
- H.subtype = { toFun := Subtype.val, map_zero' := ⋯, map_add' := ⋯ }
Instances For
The inclusion homomorphism from an additive subgroup H
contained in K
to K
.
Equations
- AddSubgroup.inclusion h = AddMonoidHom.mk' (fun (x : ↥H) => ⟨↑x, ⋯⟩) ⋯
Instances For
The inclusion homomorphism from a subgroup H
contained in K
to K
.
Equations
- Subgroup.inclusion h = MonoidHom.mk' (fun (x : ↥H) => ⟨↑x, ⋯⟩) ⋯
Instances For
The AddSubgroup G
of the AddGroup G
.
The top additive subgroup is isomorphic to the additive group.
This is the additive group version of AddSubmonoid.topEquiv
.
Equations
- AddSubgroup.topEquiv = AddSubmonoid.topEquiv
Instances For
The top subgroup is isomorphic to the group.
This is the group version of Submonoid.topEquiv
.
Equations
- Subgroup.topEquiv = Submonoid.topEquiv
Instances For
The trivial AddSubgroup
{0}
of an AddGroup
G
.
Equations
- ⋯ = ⋯
Instances For
A subgroup is either the trivial subgroup or nontrivial.
A subgroup is either the trivial subgroup or nontrivial.
A subgroup is either the trivial subgroup or contains a nonzero element.
Equations
- ⋯ = ⋯
Instances For
The inf of two AddSubgroup
s is their intersection.
Equations
- AddSubgroup.instInf = { inf := fun (H₁ H₂ : AddSubgroup G) => let __src := H₁.toAddSubmonoid ⊓ H₂.toAddSubmonoid; { toAddSubmonoid := __src, neg_mem' := ⋯ } }
Equations
- AddSubgroup.instInfSet = { sInf := fun (s : Set (AddSubgroup G)) => let __src := (⨅ S ∈ s, S.toAddSubmonoid).copy (⋂ S ∈ s, ↑S) ⋯; { toAddSubmonoid := __src, neg_mem' := ⋯ } }
The AddSubgroup
s of an AddGroup
form a complete lattice.
Equations
- AddSubgroup.instCompleteLattice = let __src := completeLatticeOfInf (AddSubgroup G) ⋯; CompleteLattice.mk ⋯ ⋯ ⋯ ⋯ ⋯ ⋯
Subgroups of a group form a complete lattice.
Equations
- Subgroup.instCompleteLattice = let __src := completeLatticeOfInf (Subgroup G) ⋯; CompleteLattice.mk ⋯ ⋯ ⋯ ⋯ ⋯ ⋯
Equations
- ⋯ = ⋯
Equations
- ⋯ = ⋯
The AddSubgroup
generated by a set
Equations
- AddSubgroup.closure k = sInf {K : AddSubgroup G | k ⊆ ↑K}
Instances For
The AddSubgroup
generated by a set includes the set.
The subgroup generated by a set includes the set.
An additive subgroup K
includes closure k
if and only if it includes k
An induction principle for additive closure membership. If p
holds for 0
and all elements of k
, and is preserved under addition and inverses, then p
holds for all elements of the additive closure of k
.
An induction principle for closure membership. If p
holds for 1
and all elements of k
, and
is preserved under multiplication and inverse, then p
holds for all elements of the closure
of k
.
A dependent version of AddSubgroup.closure_induction
.
Equations
- ⋯ = ⋯
Instances For
A dependent version of Subgroup.closure_induction
.
An induction principle for additive closure membership, for predicates with two arguments.
An induction principle for closure membership for predicates with two arguments.
If all the elements of a set s
commute, then closure s
is an additive
commutative group.
Equations
- AddSubgroup.closureAddCommGroupOfComm hcomm = let __src := (AddSubgroup.closure k).toAddGroup; AddCommGroup.mk ⋯
Instances For
If all the elements of a set s
commute, then closure s
is a commutative group.
Equations
- Subgroup.closureCommGroupOfComm hcomm = let __src := (Subgroup.closure k).toGroup; CommGroup.mk ⋯
Instances For
closure
forms a Galois insertion with the coercion to set.
Equations
- AddSubgroup.gi G = { choice := fun (s : Set G) (x : ↑(AddSubgroup.closure s) ≤ s) => AddSubgroup.closure s, gc := ⋯, le_l_u := ⋯, choice_eq := ⋯ }
Instances For
closure
forms a Galois insertion with the coercion to set.
Equations
- Subgroup.gi G = { choice := fun (s : Set G) (x : ↑(Subgroup.closure s) ≤ s) => Subgroup.closure s, gc := ⋯, le_l_u := ⋯, choice_eq := ⋯ }
Instances For
Additive closure of an additive subgroup K
equals K
Closure of a subgroup K
equals K
.
The AddSubgroup
generated by an element of an AddGroup
equals the set of
natural number multiples of the element.
The subgroup generated by an element of a group equals the set of integer number powers of the element.
The preimage of an AddSubgroup
along an AddMonoid
homomorphism
is an AddSubgroup
.
Equations
- AddSubgroup.comap f H = let __src := AddSubmonoid.comap f H.toAddSubmonoid; { carrier := ⇑f ⁻¹' ↑H, add_mem' := ⋯, zero_mem' := ⋯, neg_mem' := ⋯ }
Instances For
The preimage of a subgroup along a monoid homomorphism is a subgroup.
Equations
- Subgroup.comap f H = let __src := Submonoid.comap f H.toSubmonoid; { carrier := ⇑f ⁻¹' ↑H, mul_mem' := ⋯, one_mem' := ⋯, inv_mem' := ⋯ }
Instances For
The image of an AddSubgroup
along an AddMonoid
homomorphism
is an AddSubgroup
.
Equations
- AddSubgroup.map f H = let __src := AddSubmonoid.map f H.toAddSubmonoid; { carrier := ⇑f '' ↑H, add_mem' := ⋯, zero_mem' := ⋯, neg_mem' := ⋯ }
Instances For
The image of a subgroup along a monoid homomorphism is a subgroup.
Equations
- Subgroup.map f H = let __src := Submonoid.map f H.toSubmonoid; { carrier := ⇑f '' ↑H, mul_mem' := ⋯, one_mem' := ⋯, inv_mem' := ⋯ }
Instances For
For any subgroups H
and K
, view H ⊓ K
as a subgroup of K
.
Equations
- H.addSubgroupOf K = AddSubgroup.comap K.subtype H
Instances For
For any subgroups H
and K
, view H ⊓ K
as a subgroup of K
.
Equations
- H.subgroupOf K = Subgroup.comap K.subtype H
Instances For
If H ≤ K
, then H
as a subgroup of K
is isomorphic to H
.
Equations
- AddSubgroup.addSubgroupOfEquivOfLe h = { toFun := fun (g : ↥(H.addSubgroupOf K)) => ⟨↑↑g, ⋯⟩, invFun := fun (g : ↥H) => ⟨⟨↑g, ⋯⟩, ⋯⟩, left_inv := ⋯, right_inv := ⋯, map_add' := ⋯ }
Instances For
If H ≤ K
, then H
as a subgroup of K
is isomorphic to H
.
Equations
- Subgroup.subgroupOfEquivOfLe h = { toFun := fun (g : ↥(H.subgroupOf K)) => ⟨↑↑g, ⋯⟩, invFun := fun (g : ↥H) => ⟨⟨↑g, ⋯⟩, ⋯⟩, left_inv := ⋯, right_inv := ⋯, map_mul' := ⋯ }
Instances For
Given AddSubgroup
s H
, K
of AddGroup
s A
, B
respectively, H × K
as an AddSubgroup
of A × B
.
Equations
- H.prod K = let __src := H.prod K.toAddSubmonoid; { toAddSubmonoid := __src, neg_mem' := ⋯ }
Instances For
Product of additive subgroups is isomorphic to their product as additive groups
Equations
- H.prodEquiv K = let __src := Equiv.Set.prod ↑H ↑K; { toEquiv := __src, map_add' := ⋯ }
Instances For
Product of subgroups is isomorphic to their product as groups.
Equations
- H.prodEquiv K = let __src := Equiv.Set.prod ↑H ↑K; { toEquiv := __src, map_mul' := ⋯ }
Instances For
A version of Set.pi
for AddSubmonoid
s. Given an index set I
and a family
of submodules s : Π i, AddSubmonoid f i
, pi I s
is the AddSubmonoid
of dependent functions
f : Π i, f i
such that f i
belongs to pi I s
whenever i ∈ I
.
Equations
- AddSubmonoid.pi I s = { carrier := I.pi fun (i : η) => (s i).carrier, add_mem' := ⋯, zero_mem' := ⋯ }
Instances For
A version of Set.pi
for submonoids. Given an index set I
and a family of submodules
s : Π i, Submonoid f i
, pi I s
is the submonoid of dependent functions f : Π i, f i
such that
f i
belongs to Pi I s
whenever i ∈ I
.
Equations
- Submonoid.pi I s = { carrier := I.pi fun (i : η) => (s i).carrier, mul_mem' := ⋯, one_mem' := ⋯ }
Instances For
A version of Set.pi
for AddSubgroup
s. Given an index set I
and a family
of submodules s : Π i, AddSubgroup f i
, pi I s
is the AddSubgroup
of dependent functions
f : Π i, f i
such that f i
belongs to pi I s
whenever i ∈ I
.
Equations
- AddSubgroup.pi I H = let __src := AddSubmonoid.pi I fun (i : η) => (H i).toAddSubmonoid; { toAddSubmonoid := __src, neg_mem' := ⋯ }
Instances For
A version of Set.pi
for subgroups. Given an index set I
and a family of submodules
s : Π i, Subgroup f i
, pi I s
is the subgroup of dependent functions f : Π i, f i
such that
f i
belongs to pi I s
whenever i ∈ I
.
Equations
- Subgroup.pi I H = let __src := Submonoid.pi I fun (i : η) => (H i).toSubmonoid; { toSubmonoid := __src, inv_mem' := ⋯ }
Instances For
An AddSubgroup is normal if whenever n ∈ H
, then g + n - g ∈ H
for every g : G
N
is closed under additive conjugation
Instances
N
is closed under additive conjugation
Equations
- ⋯ = ⋯
A subgroup is characteristic if it is fixed by all automorphisms.
Several equivalent conditions are provided by lemmas of the form Characteristic.iff...
- fixed : ∀ (ϕ : G ≃* G), Subgroup.comap ϕ.toMonoidHom H = H
H
is fixed by all automorphisms
Instances
H
is fixed by all automorphisms
An AddSubgroup
is characteristic if it is fixed by all automorphisms.
Several equivalent conditions are provided by lemmas of the form Characteristic.iff...
- fixed : ∀ (ϕ : A ≃+ A), AddSubgroup.comap ϕ.toAddMonoidHom H = H
H
is fixed by all automorphisms
Instances
H
is fixed by all automorphisms
Equations
- ⋯ = ⋯
Equations
- ⋯ = ⋯
The preimage of the normalizer is contained in the normalizer of the preimage.
The preimage of the normalizer is contained in the normalizer of the preimage.
The image of the normalizer is contained in the normalizer of the image.
The image of the normalizer is contained in the normalizer of the image.
Every proper subgroup H
of G
is a proper normal subgroup of the normalizer of H
in G
.
Equations
- NormalizerCondition G = ∀ H < ⊤, H < H.normalizer
Instances For
Alternative phrasing of the normalizer condition: Only the full group is self-normalizing. This may be easier to work with, as it avoids inequalities and negations.
In a group that satisfies the normalizer condition, every maximal subgroup is normal
Commutativity of a subgroup
- is_comm : Std.Commutative fun (x x_1 : ↥H) => x * x_1
*
is commutative onH
Instances
*
is commutative on H
Commutativity of an additive subgroup
- is_comm : Std.Commutative fun (x x_1 : ↥H) => x + x_1
+
is commutative onH
Instances
+
is commutative on H
A commutative subgroup is commutative.
Equations
- AddSubgroup.IsCommutative.addCommGroup H = let __src := H.toAddGroup; AddCommGroup.mk ⋯
A commutative subgroup is commutative.
Equations
- Subgroup.IsCommutative.commGroup H = let __src := H.toGroup; CommGroup.mk ⋯
Equations
- ⋯ = ⋯
Equations
- ⋯ = ⋯
Equations
- ⋯ = ⋯
An isomorphism of groups gives an order isomorphism between the lattices of subgroups, defined by sending subgroups to their inverse images.
See also MulEquiv.mapSubgroup
which maps subgroups to their forward images.
Equations
- f.comapSubgroup = { toFun := Subgroup.comap ↑f, invFun := Subgroup.comap ↑f.symm, left_inv := ⋯, right_inv := ⋯, map_rel_iff' := ⋯ }
Instances For
An isomorphism of groups gives an order isomorphism between the lattices of subgroups, defined by sending subgroups to their forward images.
See also MulEquiv.comapSubgroup
which maps subgroups to their inverse images.
Equations
- f.mapSubgroup = { toFun := Subgroup.map ↑f, invFun := Subgroup.map ↑f.symm, left_inv := ⋯, right_inv := ⋯, map_rel_iff' := ⋯ }
Instances For
Given a set s
, conjugatesOfSet s
is the set of all conjugates of
the elements of s
.
Equations
- Group.conjugatesOfSet s = ⋃ a ∈ s, conjugatesOf a
Instances For
The set of conjugates of s
is closed under conjugation.
The normal closure of a set s
is the subgroup closure of all the conjugates of
elements of s
. It is the smallest normal subgroup containing s
.
Equations
Instances For
The normal closure of s
is a normal subgroup.
Equations
- ⋯ = ⋯
The normal core of a subgroup H
is the largest normal subgroup of G
contained in H
,
as shown by Subgroup.normalCore_eq_iSup
.
Equations
Instances For
The range of an AddMonoidHom
from an AddGroup
is an AddSubgroup
.
Equations
- f.range = (AddSubgroup.map f ⊤).copy (Set.range ⇑f) ⋯
Instances For
The range of a surjective monoid homomorphism is the whole of the codomain.
Computable alternative to AddMonoidHom.ofInjective
.
Equations
- AddMonoidHom.ofLeftInverse h = let __src := f.rangeRestrict; { toFun := ⇑f.rangeRestrict, invFun := ⇑g ∘ ⇑f.range.subtype, left_inv := h, right_inv := ⋯, map_add' := ⋯ }
Instances For
Computable alternative to MonoidHom.ofInjective
.
Equations
- MonoidHom.ofLeftInverse h = let __src := f.rangeRestrict; { toFun := ⇑f.rangeRestrict, invFun := ⇑g ∘ ⇑f.range.subtype, left_inv := h, right_inv := ⋯, map_mul' := ⋯ }
Instances For
The range of an injective additive group homomorphism is isomorphic to its domain.
Equations
- AddMonoidHom.ofInjective hf = AddEquiv.ofBijective (f.codRestrict f.range ⋯) ⋯
Instances For
The range of an injective group homomorphism is isomorphic to its domain.
Equations
- MonoidHom.ofInjective hf = MulEquiv.ofBijective (f.codRestrict f.range ⋯) ⋯
Instances For
The additive kernel of an AddMonoid
homomorphism is the AddSubgroup
of elements
such that f x = 0
Equations
- f.ker = let __src := AddMonoidHom.mker f; { toAddSubmonoid := __src, neg_mem' := ⋯ }
Instances For
The multiplicative kernel of a monoid homomorphism is the subgroup of elements x : G
such that
f x = 1
Equations
- f.ker = let __src := MonoidHom.mker f; { toSubmonoid := __src, inv_mem' := ⋯ }
Instances For
Equations
- f.decidableMemKer x = decidable_of_iff (f x = 0) ⋯
Equations
- f.decidableMemKer x = decidable_of_iff (f x = 1) ⋯
Equations
- ⋯ = ⋯
Equations
- ⋯ = ⋯
The image under an AddMonoid
hom of the AddSubgroup
generated by a set equals
the AddSubgroup
generated by the image of the set.
The image under a monoid homomorphism of the subgroup generated by a set equals the subgroup generated by the image of the set.
Given f(A) = f(B)
, ker f ≤ A
, and ker f ≤ B
, deduce that A = B
.
An additive subgroup is isomorphic to its image under an injective function. If you
have an isomorphism, use AddEquiv.addSubgroupMap
for better definitional equalities.
Equations
- H.equivMapOfInjective f hf = let __src := Equiv.Set.image (⇑f) (↑H) hf; { toEquiv := __src, map_add' := ⋯ }
Instances For
A subgroup is isomorphic to its image under an injective function. If you have an isomorphism,
use MulEquiv.subgroupMap
for better definitional equalities.
Equations
- H.equivMapOfInjective f hf = let __src := Equiv.Set.image (⇑f) (↑H) hf; { toEquiv := __src, map_mul' := ⋯ }
Instances For
The preimage of the normalizer is equal to the normalizer of the preimage of a surjective function.
The preimage of the normalizer is equal to the normalizer of the preimage of a surjective function.
The image of the normalizer is equal to the normalizer of the image of an isomorphism.
The image of the normalizer is equal to the normalizer of the image of an isomorphism.
The image of the normalizer is equal to the normalizer of the image of a bijective function.
The image of the normalizer is equal to the normalizer of the image of a bijective function.
Auxiliary definition used to define liftOfRightInverse
Equations
- f.liftOfRightInverseAux f_inv hf g hg = { toFun := fun (b : G₂) => g (f_inv b), map_zero' := ⋯, map_add' := ⋯ }
Instances For
Auxiliary definition used to define liftOfRightInverse
Equations
- f.liftOfRightInverseAux f_inv hf g hg = { toFun := fun (b : G₂) => g (f_inv b), map_one' := ⋯, map_mul' := ⋯ }
Instances For
liftOfRightInverse f f_inv hf g hg
is the unique additive group homomorphism φ
- such that
φ.comp f = g
(AddMonoidHom.liftOfRightInverse_comp
), - where
f : G₁ →+ G₂
has a RightInversef_inv
(hf
), - and
g : G₂ →+ G₃
satisfieshg : f.ker ≤ g.ker
. SeeAddMonoidHom.eq_liftOfRightInverse
for the uniqueness lemma.
G₁.
| \
f | \ g
| \
v \⌟
G₂----> G₃
∃!φ
Equations
- One or more equations did not get rendered due to their size.
Instances For
liftOfRightInverse f hf g hg
is the unique group homomorphism φ
- such that
φ.comp f = g
(MonoidHom.liftOfRightInverse_comp
), - where
f : G₁ →+* G₂
has a RightInversef_inv
(hf
), - and
g : G₂ →+* G₃
satisfieshg : f.ker ≤ g.ker
.
See MonoidHom.eq_liftOfRightInverse
for the uniqueness lemma.
G₁.
| \
f | \ g
| \
v \⌟
G₂----> G₃
∃!φ
Equations
- One or more equations did not get rendered due to their size.
Instances For
A non-computable version of AddMonoidHom.liftOfRightInverse
for when no
computable right inverse is available.
Equations
- f.liftOfSurjective hf = f.liftOfRightInverse (Function.surjInv hf) ⋯
Instances For
A non-computable version of MonoidHom.liftOfRightInverse
for when no computable right
inverse is available, that uses Function.surjInv
.
Equations
- f.liftOfSurjective hf = f.liftOfRightInverse (Function.surjInv hf) ⋯
Instances For
Equations
- ⋯ = ⋯
Equations
- ⋯ = ⋯
Equations
- ⋯ = ⋯
the AddMonoidHom
from the preimage of an
additive subgroup to itself.
Equations
- f.addSubgroupComap H' = f.addSubmonoidComap H'.toAddSubmonoid
Instances For
the AddMonoidHom
from an additive subgroup to its image
Equations
- f.addSubgroupMap H = f.addSubmonoidMap H.toAddSubmonoid
Instances For
Makes the identity additive isomorphism from a proof two subgroups of an additive group are equal.
Equations
- AddEquiv.addSubgroupCongr h = let __src := Equiv.setCongr ⋯; { toEquiv := __src, map_add' := ⋯ }
Instances For
Makes the identity isomorphism from a proof two subgroups of a multiplicative group are equal.
Equations
- MulEquiv.subgroupCongr h = let __src := Equiv.setCongr ⋯; { toEquiv := __src, map_mul' := ⋯ }
Instances For
An additive subgroup is isomorphic to its image under an isomorphism. If you only
have an injective map, use AddSubgroup.equiv_map_of_injective
.
Equations
- e.addSubgroupMap H = e.addSubmonoidMap H.toAddSubmonoid
Instances For
A subgroup is isomorphic to its image under an isomorphism. If you only have an injective map,
use Subgroup.equiv_map_of_injective
.
Equations
- e.subgroupMap H = e.submonoidMap H.toSubmonoid
Instances For
Equations
- ⋯ = ⋯
Equations
- ⋯ = ⋯
Equations
- ⋯ = ⋯
Equations
- ⋯ = ⋯
Equations
- ⋯ = ⋯
Elements of disjoint, normal subgroups commute.
The conjugacy classes that are not trivial.
Equations
- ConjClasses.noncenter G = {x : ConjClasses G | x.carrier.Nontrivial}