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 NareGroupsAis anAddGroupH KareSubgroups ofGorAddSubgroups ofAxis an element of typeGor typeAf g : N →* Gare group homomorphismss kare sets of elements of typeG
Definitions in the file:
Subgroup G: the type of subgroups of a groupGAddSubgroup A: the type of subgroups of an additive groupACompleteLattice (Subgroup G): the subgroups ofGform a complete latticeSubgroup.closure k: the minimal subgroup that includes the setkSubgroup.subtype: the natural group homomorphism from a subgroup of groupGtoGSubgroup.gi:closureforms a Galois insertion with the coercion to setSubgroup.comap H f: the preimage of a subgroupHalong the group homomorphismfis also a subgroupSubgroup.map f H: the image of a subgroupHalong the group homomorphismfis also a subgroupSubgroup.prod H K: the product of subgroupsH,Kof groupsG,Nrespectively,H × Kis a subgroup ofG × NMonoidHom.range f: the range of the group homomorphismfis a subgroupMonoidHom.ker f: the kernel of a group homomorphismfis the subgroup of elementsx : Gsuch thatf x = 1MonoidHom.eq_locus f g: given group homomorphismsf,g, the elements ofGsuch thatf x = g xform 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 AddSubgroups 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 AddSubgroups 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 AddSubgroups 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 AddSubgroups H, K of AddGroups 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 AddSubmonoids. 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 AddSubgroups. 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
Nis 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
His 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
His 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_liftOfRightInversefor 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}