|
#############################################################################
##
## This file is part of GAP, a system for computational discrete algebra.
## This file's authors include Thomas Breuer, Frank Celler, Bettina Eick,
## Heiko Theißen.
##
## Copyright of GAP belongs to its developers, whose names are too numerous
## to list here. Please refer to the COPYRIGHT file for details.
##
## SPDX-License-Identifier: GPL-2.0-or-later
##
## This file contains the declarations of operations for groups.
##
#############################################################################
##
## <#GAPDoc Label="[1]{grp}">
## Unless explicitly declared otherwise, all subgroup series are descending.
## That is they are stored in decreasing order.
## <#/GAPDoc>
##
## <#GAPDoc Label="[2]{grp}">
## If a group <M>U</M> is created as a subgroup of another group <M>G</M>,
## <M>G</M> becomes the parent of <M>U</M>.
## There is no <Q>universal</Q> parent group,
## parent-child chains can be arbitrary long.
## &GAP; stores the result of some operations
## (such as <Ref Oper="Normalizer" Label="for two groups"/>)
## with the parent as an attribute.
## <#/GAPDoc>
##
#############################################################################
##
#V InfoGroup
##
## <#GAPDoc Label="InfoGroup">
## <ManSection>
## <InfoClass Name="InfoGroup"/>
##
## <Description>
## is the info class for the generic group theoretic functions
## (see <Ref Sect="Info Functions"/>).
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareInfoClass( "InfoGroup" );
#############################################################################
##
#C IsGroup( <obj> )
##
## <#GAPDoc Label="IsGroup">
## <ManSection>
## <Filt Name="IsGroup" Arg='obj' Type='Category'/>
##
## <Description>
## A group is a magma-with-inverses (see <Ref Filt="IsMagmaWithInverses"/>)
## and associative (see <Ref Prop="IsAssociative"/>) multiplication.
## <P/>
## <C>IsGroup</C> tests whether the object <A>obj</A> fulfills these conditions,
## it does <E>not</E> test whether <A>obj</A> is a set of elements that forms a group
## under multiplication;
## use <Ref Attr="AsGroup"/> if you want to perform such a test.
## (See <Ref Sect="Categories"/> for details about categories.)
## <Example><![CDATA[
## gap> IsGroup(g);
## true
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareSynonym( "IsGroup", IsMagmaWithInverses and IsAssociative );
InstallTrueMethod( IsFiniteOrderElementCollection, IsGroup and IsFinite );
#############################################################################
##
#A GeneratorsOfGroup( <G> )
##
## <#GAPDoc Label="GeneratorsOfGroup">
## <ManSection>
## <Attr Name="GeneratorsOfGroup" Arg='G'/>
##
## <Description>
## returns a list of generators of the group <A>G</A>.
## If <A>G</A> has been created by the command
## <Ref Oper="GroupWithGenerators"/> with argument <A>gens</A>,
## then the list returned by <Ref Attr="GeneratorsOfGroup"/>
## will be equal to <A>gens</A>. For such a group, each generator
## can also be accessed using the <C>.</C> operator
## (see <Ref Attr="GeneratorsOfDomain"/>): for a positive integer
## <M>i</M>, <C><A>G</A>.i</C> returns the <M>i</M>-th element of
## the list returned by <Ref Attr="GeneratorsOfGroup"/>. Moreover,
## if <A>G</A> is a free group, and <C>name</C> is the name of a
## generator of <A>G</A> then <C><A>G</A>.name</C> also returns
## this generator.
## <Example><![CDATA[
## gap> g:=GroupWithGenerators([(1,2,3,4),(1,2)]);
## Group([ (1,2,3,4), (1,2) ])
## gap> GeneratorsOfGroup(g);
## [ (1,2,3,4), (1,2) ]
## ]]></Example>
## <P/>
## While in this example &GAP; displays the group via the generating set
## stored in the attribute <Ref Attr="GeneratorsOfGroup"/>,
## the methods installed for <Ref Func="View"/> will in general display only
## some information about the group which may even be just the fact that it
## is a group.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareSynonymAttr( "GeneratorsOfGroup", GeneratorsOfMagmaWithInverses );
#############################################################################
##
#O GroupString( <G>, <name> )
##
## <ManSection>
## <Oper Name="GroupString" Arg='G, name'/>
##
## <Description>
## returns a short string (usually less than one line) with information
## about the group <A>G</A>. <A>name</A> is a display name if the group <A>G</A> does
## not have one.
## </Description>
## </ManSection>
##
DeclareOperation( "GroupString", [IsGroup,IsString] );
#############################################################################
##
#P IsCyclic( <G> )
##
## <#GAPDoc Label="IsCyclic">
## <ManSection>
## <Prop Name="IsCyclic" Arg='G'/>
##
## <Description>
## A group is <E>cyclic</E> if it can be generated by one element.
## For a cyclic group, one can compute a generating set consisting of only
## one element using <Ref Attr="MinimalGeneratingSet"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsCyclic", IsGroup );
InstallSubsetMaintenance( IsCyclic, IsGroup and IsCyclic, IsGroup );
InstallFactorMaintenance( IsCyclic,
IsGroup and IsCyclic, IsObject, IsGroup );
InstallTrueMethod( IsCyclic, IsGroup and IsTrivial );
InstallTrueMethod( IsCommutative, IsGroup and IsCyclic );
#############################################################################
##
#P IsElementaryAbelian( <G> )
##
## <#GAPDoc Label="IsElementaryAbelian">
## <ManSection>
## <Prop Name="IsElementaryAbelian" Arg='G'/>
##
## <Description>
## A group <A>G</A> is elementary abelian if it is commutative and if there is a
## prime <M>p</M> such that the order of each element in <A>G</A> divides <M>p</M>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsElementaryAbelian", IsGroup );
InstallSubsetMaintenance( IsElementaryAbelian,
IsGroup and IsElementaryAbelian, IsGroup );
InstallFactorMaintenance( IsElementaryAbelian,
IsGroup and IsElementaryAbelian, IsObject, IsGroup );
InstallTrueMethod( IsElementaryAbelian, IsGroup and IsTrivial );
InstallTrueMethod( IsCommutative, IsGroup and IsElementaryAbelian );
#############################################################################
##
#P IsFinitelyGeneratedGroup( <G> )
##
## <#GAPDoc Label="IsFinitelyGeneratedGroup">
## <ManSection>
## <Prop Name="IsFinitelyGeneratedGroup" Arg='G'/>
##
## <Description>
## tests whether the group <A>G</A> can be generated by a finite number of
## generators. (This property is mainly used to obtain finiteness
## conditions.)
## <P/>
## Note that this is a pure existence statement. Even if a group is known
## to be generated by a finite number of elements, it can be very hard or
## even impossible to obtain such a generating set if it is not known.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsFinitelyGeneratedGroup", IsGroup );
InstallTrueMethod( IsGroup, IsFinitelyGeneratedGroup );
InstallFactorMaintenance( IsFinitelyGeneratedGroup,
IsGroup and IsFinitelyGeneratedGroup, IsObject, IsGroup );
# make IsFinitelyGeneratedGroup equivalent to IsGroup and IsFinitelyGeneratedMagma
InstallTrueMethod( IsFinitelyGeneratedGroup, IsGroup and IsFinitelyGeneratedMagma );
InstallTrueMethod( HasIsFinitelyGeneratedGroup, IsGroup and HasIsFinitelyGeneratedMagma );
InstallTrueMethod( IsFinitelyGeneratedMagma, IsFinitelyGeneratedGroup );
InstallTrueMethod( HasIsFinitelyGeneratedMagma, HasIsFinitelyGeneratedGroup );
#############################################################################
##
#P IsSubsetLocallyFiniteGroup(<U>) . . . . test if a group is locally finite
##
## <#GAPDoc Label="IsSubsetLocallyFiniteGroup">
## <ManSection>
## <Prop Name="IsSubsetLocallyFiniteGroup" Arg='U'/>
##
## <Description>
## A group is called locally finite if every finitely generated subgroup is
## finite. This property checks whether the group <A>U</A> is a subset of a
## locally finite group. This is used to check whether finite generation
## will imply finiteness, as it does for example for permutation groups.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsSubsetLocallyFiniteGroup", IsGroup );
# this true method will enforce that many groups are finite, which is needed
# implicitly
InstallTrueMethod( IsFinite, IsFinitelyGeneratedGroup and IsGroup
and IsSubsetLocallyFiniteGroup );
InstallTrueMethod( IsSubsetLocallyFiniteGroup, IsFinite and IsGroup );
InstallSubsetMaintenance( IsSubsetLocallyFiniteGroup,
IsGroup and IsSubsetLocallyFiniteGroup, IsGroup );
#############################################################################
##
#M IsSubsetLocallyFiniteGroup( <G> ) . . . for magmas with inverses of FFEs
##
InstallTrueMethod( IsSubsetLocallyFiniteGroup,
IsFFECollection and IsMagmaWithInverses );
#############################################################################
##
## <#GAPDoc Label="[3]{grp}">
## The following filters and operations indicate capabilities of &GAP;.
## They can be used in the method selection or algorithms to check whether
## it is feasible to compute certain operations for a given group.
## In general, they return <K>true</K> if good algorithms for the given arguments
## are available in &GAP;.
## An answer <K>false</K> indicates that no method for this group may exist,
## or that the existing methods might run into problems.
## <P/>
## Typical examples when this might happen is with finitely presented
## groups, for which many of the methods cannot be guaranteed to succeed in
## all situations.
## <P/>
## The willingness of &GAP; to perform certain operations may change,
## depending on which further information is known about the arguments.
## Therefore the filters used are not implemented as properties but as
## <Q>other filters</Q> (see <Ref Sect="Properties"/> and <Ref Sect="Other Filters"/>).
## <#/GAPDoc>
##
#############################################################################
##
#F CanEasilyTestMembership( <G> )
##
## <#GAPDoc Label="CanEasilyTestMembership">
## <ManSection>
## <Filt Name="CanEasilyTestMembership" Arg='G'/>
##
## <Description>
## This filter indicates whether &GAP; can test membership of elements in
## the group <A>G</A>
## (via the operation <Ref Oper="\in" Label="for a collection"/>)
## in reasonable time.
## It is used by the method selection to decide whether an algorithm
## that relies on membership tests may be used.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareFilter( "CanEasilyTestMembership" );
#############################################################################
##
#F CanEasilyComputeWithIndependentGensAbelianGroup( <G> )
##
## <#GAPDoc Label="CanEasilyComputeWithIndependentGensAbelianGroup">
## <ManSection>
## <Filt Name="CanEasilyComputeWithIndependentGensAbelianGroup" Arg='G'/>
##
## <Description>
## This filter indicates whether &GAP; can in reasonable time compute
## independent abelian generators of the group <A>G</A>
## (via <Ref Attr="IndependentGeneratorsOfAbelianGroup"/>) and
## then can decompose arbitrary group elements with respect to these
## generators using <Ref Oper="IndependentGeneratorExponents"/>.
##
## It is used by the method selection to decide whether an algorithm
## that relies on these two operations may be used.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareFilter( "CanEasilyComputeWithIndependentGensAbelianGroup" );
#############################################################################
##
#F CanComputeSizeAnySubgroup( <G> )
##
## <#GAPDoc Label="CanComputeSizeAnySubgroup">
## <ManSection>
## <Filt Name="CanComputeSizeAnySubgroup" Arg='G'/>
##
## <Description>
## This filter indicates whether &GAP; can easily compute the size of any
## subgroup of the group <A>G</A>.
## (This is for example advantageous if one can test that a stabilizer index
## equals the length of the orbit computed so far to stop early.)
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareFilter( "CanComputeSizeAnySubgroup" );
InstallTrueMethod(CanEasilyTestMembership,
IsFinite and CanComputeSizeAnySubgroup);
InstallTrueMethod(CanComputeSize,CanComputeSizeAnySubgroup);
InstallTrueMethod( CanComputeSize, IsTrivial );
# these implications can create problems with some fp groups. Therefore we
# are a bit less eager
#InstallTrueMethod( CanComputeSizeAnySubgroup, IsTrivial );
#InstallTrueMethod( CanEasilyTestMembership, IsTrivial );
#############################################################################
##
#F CanComputeIndex( <G>, <H> )
##
## <#GAPDoc Label="CanComputeIndex">
## <ManSection>
## <Oper Name="CanComputeIndex" Arg='G, H'/>
##
## <Description>
## This function indicates whether the index <M>[<A>G</A>:<A>H</A>]</M>
## (which might be <Ref Var="infinity"/>) can be computed.
## It assumes that <M><A>H</A> \leq <A>G</A></M>
## (see <Ref Oper="CanComputeIsSubset"/>).
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "CanComputeIndex", [IsGroup,IsGroup] );
#############################################################################
##
#P KnowsHowToDecompose( <G>[, <gens>] )
##
## <#GAPDoc Label="KnowsHowToDecompose">
## <ManSection>
## <Prop Name="KnowsHowToDecompose" Arg='G[, gens]'/>
##
## <Description>
## Tests whether the group <A>G</A> can decompose elements in the generators
## <A>gens</A>.
## If <A>gens</A> is not given it tests, whether it can decompose in the
## generators given in the <Ref Attr="GeneratorsOfGroup"/> value of
## <A>G</A>.
## <P/>
## This property can be used for example to check whether a
## group homomorphism by images
## (see <Ref Func="GroupHomomorphismByImages"/>) can be reasonably defined
## from this group.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "KnowsHowToDecompose", IsGroup );
DeclareOperation( "KnowsHowToDecompose", [ IsGroup, IsList ] );
#############################################################################
##
#P IsPGroup( <G> ) . . . . . . . . . . . . . . . . . is a group a p-group ?
##
## <#GAPDoc Label="IsPGroup">
## <ManSection>
## <Prop Name="IsPGroup" Arg='G'/>
##
## <Description>
## <Index Key="p-group"><M>p</M>-group</Index>
## A <E><M>p</M>-group</E> is a group in which the order
## (see <Ref Attr="Order"/>) of every element is of the form <M>p^n</M>
## for a prime integer <M>p</M> and a nonnegative integer <M>n</M>.
## <Ref Prop="IsPGroup"/> returns <K>true</K> if <A>G</A> is a
## <M>p</M>-group, and <K>false</K> otherwise.
## <P/>
## Finite <M>p</M>-groups are precisely those groups whose order
## (see <Ref Attr="Size"/>) is <M>1</M> or a prime power
## (see <Ref Func="IsPrimePowerInt"/>,
## and are always nilpotent.
## <P/>
## Note that <M>p</M>-groups can also be infinite, and in that case,
## need not be nilpotent.
## <P/>
## <Example><![CDATA[
## gap> IsPGroup( DihedralGroup( 8 ) );
## true
## gap> IsPGroup( TrivialGroup() );
## true
## gap> IsPGroup( DihedralGroup( 10 ) );
## false
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsPGroup", IsGroup );
InstallTrueMethod( IsGroup, IsPGroup );
InstallSubsetMaintenance( IsPGroup, IsPGroup, IsGroup );
InstallFactorMaintenance( IsPGroup, IsPGroup, IsObject, IsGroup );
InstallTrueMethod( IsPGroup, IsGroup and IsTrivial );
InstallTrueMethod( IsPGroup, IsGroup and IsElementaryAbelian );
#############################################################################
##
#P IsPowerfulPGroup( <G> ) . . . . . . . . . is a group a powerful p-group ?
##
## <#GAPDoc Label="IsPowerfulPGroup">
## <ManSection>
## <Prop Name="IsPowerfulPGroup" Arg='G'/>
##
## <Description>
## <Index Key="PowerfulPGroup">Powerful <M>p</M>-group</Index>
## A finite <M>p</M>-group <A>G</A> is said to be a <E>powerful <M>p</M>-group</E>
## if the commutator subgroup <M>[<A>G</A>,<A>G</A>]</M> is contained in
## <M><A>G</A>^{p}</M> if the prime <M>p</M> is odd, or if
## <M>[<A>G</A>,<A>G</A>]</M> is contained in <M><A>G</A>^{4}</M>
## if <M>p = 2</M>. The subgroup <M><A>G</A>^{p}</M> is called the first
## Agemo subgroup, (see <Ref Func="Agemo"/>).
## <Ref Prop="IsPowerfulPGroup"/> returns <K>true</K> if <A>G</A> is a
## powerful <M>p</M>-group, and <K>false</K> otherwise.
## <E>Note: </E>This function returns <K>true</K> if <A>G</A> is the trivial
## group.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsPowerfulPGroup", IsGroup );
InstallTrueMethod( IsPGroup, IsPowerfulPGroup );
#Quotients of powerful p-groups are powerful
InstallFactorMaintenance( IsPowerfulPGroup,
IsPowerfulPGroup, IsGroup, IsGroup );
#abelian p-groups are powerful
InstallTrueMethod( IsPowerfulPGroup, IsFinite and IsPGroup and IsAbelian );
#############################################################################
##
#P IsRegularPGroup( <G> ) . . . . . . . . . . is a group a regular p-group ?
##
## <#GAPDoc Label="IsRegularPGroup">
## <ManSection>
## <Prop Name="IsRegularPGroup" Arg='G'/>
##
## <Description>
## <Index Key="RegularPGroup">Regular <M>p</M>-group</Index>
## A finite <M>p</M>-group <A>G</A> is a <E>regular <M>p</M>-group</E>
## if for all <M>a,b</M> in <A>G</A>, one has <M>a^p b^p = (a b)^p c^p</M>
## where <M>c</M> is an element of the derived subgroup of the group generated
## by <M>a</M> and <M>b</M> (see <Cite Key="Hal34"/>).
## <Ref Prop="IsRegularPGroup"/> returns <K>true</K> if <A>G</A> is a
## regular <M>p</M>-group, and <K>false</K> otherwise.
## <E>Note: </E>This function returns <K>true</K> if <A>G</A> is the trivial
## group.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsRegularPGroup", IsGroup );
InstallTrueMethod( IsPGroup, IsRegularPGroup );
InstallSubsetMaintenance( IsRegularPGroup, IsRegularPGroup, IsGroup );
InstallFactorMaintenance( IsPGroup, IsRegularPGroup, IsObject, IsGroup );
#abelian p-groups are regular
InstallTrueMethod( IsRegularPGroup, IsFinite and IsPGroup and IsAbelian );
#############################################################################
##
#A PrimePGroup( <G> )
##
## <#GAPDoc Label="PrimePGroup">
## <ManSection>
## <Attr Name="PrimePGroup" Arg='G'/>
##
## <Description>
## If <A>G</A> is a nontrivial <M>p</M>-group
## (see <Ref Prop="IsPGroup"/>), <Ref Attr="PrimePGroup"/> returns
## the prime integer <M>p</M>;
## if <A>G</A> is trivial then <Ref Attr="PrimePGroup"/> returns
## <K>fail</K>.
## Otherwise an error is issued.
## <P/>
## (One should avoid a common error of writing
## <C>if IsPGroup(g) then ... PrimePGroup(g) ...</C> where the code
## represented by dots assumes that <C>PrimePGroup(g)</C> is an integer.)
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "PrimePGroup", IsPGroup );
#############################################################################
##
#A PClassPGroup( <G> )
##
## <#GAPDoc Label="PClassPGroup">
## <ManSection>
## <Attr Name="PClassPGroup" Arg='G'/>
##
## <Description>
## The <M>p</M>-class of a <M>p</M>-group <A>G</A>
## (see <Ref Prop="IsPGroup"/>)
## is the length of the lower <M>p</M>-central series
## (see <Ref Oper="PCentralSeries"/>) of <A>G</A>.
## If <A>G</A> is not a <M>p</M>-group then an error is issued.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "PClassPGroup", IsPGroup );
#############################################################################
##
#A RankPGroup( <G> )
##
## <#GAPDoc Label="RankPGroup">
## <ManSection>
## <Attr Name="RankPGroup" Arg='G'/>
##
## <Description>
## For a <M>p</M>-group <A>G</A> (see <Ref Prop="IsPGroup"/>),
## <Ref Attr="RankPGroup"/> returns the <E>rank</E> of <A>G</A>,
## which is defined as the minimal size of a generating system of <A>G</A>.
## If <A>G</A> is not a <M>p</M>-group then an error is issued.
## <Example><![CDATA[
## gap> h:=Group((1,2,3,4),(1,3));;
## gap> PClassPGroup(h);
## 2
## gap> RankPGroup(h);
## 2
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "RankPGroup", IsPGroup );
#############################################################################
##
#P IsNilpotentGroup( <G> )
##
## <#GAPDoc Label="IsNilpotentGroup">
## <ManSection>
## <Prop Name="IsNilpotentGroup" Arg='G'/>
##
## <Description>
## A group is <E>nilpotent</E> if the lower central series
## (see <Ref Attr="LowerCentralSeriesOfGroup"/> for a definition)
## reaches the trivial subgroup in a finite number of steps.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsNilpotentGroup", IsGroup );
InstallTrueMethod( IsGroup, IsNilpotentGroup );
InstallSubsetMaintenance( IsNilpotentGroup,
IsGroup and IsNilpotentGroup, IsGroup );
InstallFactorMaintenance( IsNilpotentGroup,
IsGroup and IsNilpotentGroup, IsObject, IsGroup );
InstallTrueMethod( IsNilpotentGroup, IsGroup and IsCommutative );
InstallTrueMethod( IsNilpotentGroup, IsGroup and IsPGroup and IsFinite );
#############################################################################
##
#P IsPerfectGroup( <G> )
##
## <#GAPDoc Label="IsPerfectGroup">
## <ManSection>
## <Prop Name="IsPerfectGroup" Arg='G'/>
##
## <Description>
## A group is <E>perfect</E> if it equals its derived subgroup
## (see <Ref Attr="DerivedSubgroup"/>).
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsPerfectGroup", IsGroup );
InstallTrueMethod( IsGroup, IsPerfectGroup );
InstallIsomorphismMaintenance( IsPerfectGroup, IsGroup, IsGroup );
InstallFactorMaintenance( IsPerfectGroup,
IsGroup and IsPerfectGroup, IsObject, IsGroup );
InstallTrueMethod( IsPerfectGroup, IsGroup and IsTrivial );
#############################################################################
##
#P IsSimpleGroup( <G> )
#P IsNonabelianSimpleGroup( <G> )
##
## <#GAPDoc Label="IsSimpleGroup">
## <ManSection>
## <Prop Name="IsSimpleGroup" Arg='G'/>
## <Prop Name="IsNonabelianSimpleGroup" Arg='G'/>
##
## <Description>
## A group is <E>simple</E> if it is nontrivial and has no nontrivial normal
## subgroups. A <E>nonabelian simple</E> group is simple and not abelian.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsSimpleGroup", IsGroup );
InstallTrueMethod( IsGroup and IsNonTrivial, IsSimpleGroup );
DeclareSynonymAttr( "IsNonabelianSimpleGroup", IsSimpleGroup and IsPerfectGroup );
# ... implies not abelian, not nilpotent (also not solvable, but
# HasIsSolvableGroup only gets defined later)
InstallTrueMethod( HasIsAbelian, IsNonabelianSimpleGroup );
InstallTrueMethod( HasIsNilpotentGroup, IsNonabelianSimpleGroup );
#InstallTrueMethod( HasIsSolvableGroup, IsNonabelianSimpleGroup );
InstallIsomorphismMaintenance( IsSimpleGroup, IsGroup, IsGroup );
# abelian simple groups are cyclic p-groups and not perfect
InstallTrueMethod( IsCyclic, IsSimpleGroup and IsAbelian );
InstallTrueMethod( IsPGroup, IsSimpleGroup and IsAbelian );
InstallTrueMethod( HasIsPerfectGroup, IsSimpleGroup and IsAbelian );
InstallTrueMethod( HasIsNonabelianSimpleGroup, IsSimpleGroup and IsAbelian );
#############################################################################
##
#P IsSporadicSimpleGroup( <G> )
##
## <ManSection>
## <Prop Name="IsSporadicSimpleGroup" Arg='G'/>
##
## <Description>
## A group is <E>sporadic simple</E> if it is one of the
## <M>26</M> sporadic simple groups;
## these are (in &ATLAS; notation, see <Cite Key="CCN85"/>)
## <M>M_{11}</M>, <M>M_{12}</M>, <M>J_1</M>, <M>M_{22}</M>, <M>J_2</M>,
## <M>M_{23}</M>, <M>HS</M>, <M>J_3</M>, <M>M_{24}</M>, <M>M^cL</M>,
## <M>He</M>, <M>Ru</M>, <M>Suz</M>, <M>O'N</M>, <M>Co_3</M>, <M>Co_2</M>,
## <M>Fi_{22}</M>, <M>HN</M>, <M>Ly</M>, <M>Th</M>, <M>Fi_{23}</M>,
## <M>Co_1</M>, <M>J_4</M>, <M>Fi_{24}'</M>, <M>B</M>, and <M>M</M>.
## <P/>
## This property can be used for example for selecting the character tables
## of the sporadic simple groups,
## see the documentation of the &GAP; package <Package>CTblLib</Package>.
## </Description>
## </ManSection>
##
DeclareProperty( "IsSporadicSimpleGroup", IsGroup );
InstallTrueMethod( IsNonabelianSimpleGroup, IsSporadicSimpleGroup );
InstallIsomorphismMaintenance( IsSporadicSimpleGroup, IsGroup, IsGroup );
#############################################################################
##
#P IsAlmostSimpleGroup( <G> )
##
## <#GAPDoc Label="IsAlmostSimpleGroup">
## <ManSection>
## <Prop Name="IsAlmostSimpleGroup" Arg='G'/>
##
## <Description>
## A group <A>G</A> is <E>almost simple</E> if a nonabelian simple group
## <M>S</M> exists such that <A>G</A> is isomorphic to a subgroup of the
## automorphism group of <M>S</M> that contains all inner automorphisms of
## <M>S</M>.
## <P/>
## Equivalently, <A>G</A> is almost simple if and only if it has a unique
## minimal normal subgroup <M>N</M> and if <M>N</M> is a nonabelian simple
## group.
## <P/>
## <!--
## (Note that the centralizer of <M>N</M> in <A>G</A> is trivial because
## it is a normal subgroup of <A>G</A> that intersects <M>N</M>
## trivially,
## so if it would be nontrivial then it would contain another minimal normal
## subgroup of <A>G</A>.
## Hence the conjugation action of <A>G</A> on <M>N</M> defines an embedding
## of <A>G</A> into the automorphism group of <M>N</M>,
## and this embedding maps <M>N</M> to the group of inner automorphisms of
## <M>N</M>.)
## <P/>
## -->
## Note that an almost simple group is <E>not</E> defined as an extension of
## a simple group by outer automorphisms,
## since we want to exclude extensions of groups of prime order.
## In particular, a <E>simple</E> group is <E>almost simple</E> if and only
## if it is nonabelian.
## <P/>
## <Example><![CDATA[
## gap> IsAlmostSimpleGroup( AlternatingGroup( 5 ) );
## true
## gap> IsAlmostSimpleGroup( SymmetricGroup( 5 ) );
## true
## gap> IsAlmostSimpleGroup( SymmetricGroup( 3 ) );
## false
## gap> IsAlmostSimpleGroup( SL( 2, 5 ) );
## false
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsAlmostSimpleGroup", IsGroup );
InstallTrueMethod( IsGroup and IsNonTrivial, IsAlmostSimpleGroup );
# nonabelian simple groups are almost simple
InstallTrueMethod( IsAlmostSimpleGroup, IsNonabelianSimpleGroup );
#############################################################################
##
#P IsQuasisimpleGroup( <G> )
##
## <#GAPDoc Label="IsQuasisimpleGroup">
## <ManSection>
## <Prop Name="IsQuasisimpleGroup" Arg='G'/>
##
## <Description>
## A group <A>G</A> is <E>quasisimple</E> if <A>G</A> is perfect
## (see <Ref Prop="IsPerfectGroup"/>)
## and if <A>G</A><M>/Z(</M><A>G</A><M>)</M> is simple
## (see <Ref Prop="IsSimpleGroup"/>), where <M>Z(</M><A>G</A><M>)</M>
## is the centre of <A>G</A> (see <Ref Attr="Centre"/>).
## <P/>
## <Example><![CDATA[
## gap> IsQuasisimpleGroup( AlternatingGroup( 5 ) );
## true
## gap> IsQuasisimpleGroup( SymmetricGroup( 5 ) );
## false
## gap> IsQuasisimpleGroup( SL( 2, 5 ) );
## true
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsQuasisimpleGroup", IsGroup );
InstallTrueMethod( IsGroup and IsNonTrivial, IsQuasisimpleGroup );
# Nonabelian simple groups are quasisimple, quasisimple groups are perfect.
InstallTrueMethod( IsQuasisimpleGroup, IsNonabelianSimpleGroup );
InstallTrueMethod( IsPerfectGroup, IsQuasisimpleGroup );
# We can expect that people will try the name with capital s.
DeclareSynonymAttr( "IsQuasiSimpleGroup", IsQuasisimpleGroup );
#############################################################################
##
#P IsSupersolvableGroup( <G> )
##
## <#GAPDoc Label="IsSupersolvableGroup">
## <ManSection>
## <Prop Name="IsSupersolvableGroup" Arg='G'/>
##
## <Description>
## A finite group is <E>supersolvable</E> if it has a normal series
## with cyclic factors.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsSupersolvableGroup", IsGroup );
InstallTrueMethod( IsGroup, IsSupersolvableGroup );
InstallSubsetMaintenance( IsSupersolvableGroup,
IsGroup and IsSupersolvableGroup, IsGroup );
InstallFactorMaintenance( IsSupersolvableGroup,
IsGroup and IsSupersolvableGroup, IsObject, IsGroup );
InstallTrueMethod( IsSupersolvableGroup, IsNilpotentGroup );
#############################################################################
##
#P IsMonomialGroup( <G> )
##
## <#GAPDoc Label="IsMonomialGroup">
## <ManSection>
## <Prop Name="IsMonomialGroup" Arg='G'/>
##
## <Description>
## A finite group is <E>monomial</E> if every irreducible complex character is
## induced from a linear character of a subgroup.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsMonomialGroup", IsGroup );
InstallTrueMethod( IsGroup, IsMonomialGroup );
InstallFactorMaintenance( IsMonomialGroup,
IsGroup and IsMonomialGroup, IsObject, IsGroup );
InstallTrueMethod( IsMonomialGroup, IsSupersolvableGroup and IsFinite );
#############################################################################
##
#P IsSolvableGroup( <G> )
##
## <#GAPDoc Label="IsSolvableGroup">
## <ManSection>
## <Prop Name="IsSolvableGroup" Arg='G'/>
##
## <Description>
## A group is <E>solvable</E> if the derived series
## (see <Ref Attr="DerivedSeriesOfGroup"/> for a definition)
## reaches the trivial subgroup in a finite number of steps.
## <P/>
## For finite groups this is the same as being polycyclic
## (see <Ref Prop="IsPolycyclicGroup"/>),
## and each polycyclic group is solvable,
## but there are infinite solvable groups that are not polycyclic.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsSolvableGroup", IsGroup );
InstallTrueMethod( IsGroup, IsSolvableGroup );
InstallSubsetMaintenance( IsSolvableGroup,
IsGroup and IsSolvableGroup, IsGroup );
InstallFactorMaintenance( IsSolvableGroup,
IsGroup and IsSolvableGroup, IsObject, IsGroup );
## For finite groups, supersolvability implies monomiality, and this implies
## solvability.
## But monomiality is defined only for finite groups, for the general case
## we need the direct implication from supersolvability to solvability.
InstallTrueMethod( IsSolvableGroup, IsMonomialGroup );
InstallTrueMethod( IsSolvableGroup, IsSupersolvableGroup );
# nontrivial solvable groups are not perfect
InstallTrueMethod( HasIsPerfectGroup, IsGroup and IsSolvableGroup and IsNonTrivial );
# nonabelian simple groups are not solvable
InstallTrueMethod( HasIsSolvableGroup, IsNonabelianSimpleGroup );
#############################################################################
##
#P IsPolycyclicGroup( <G> )
##
## <#GAPDoc Label="IsPolycyclicGroup">
## <ManSection>
## <Prop Name="IsPolycyclicGroup" Arg='G'/>
##
## <Description>
## A group is polycyclic if it has a subnormal series with cyclic factors.
## For finite groups this is the same as if the group is solvable
## (see <Ref Prop="IsSolvableGroup"/>).
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsPolycyclicGroup", IsGroup );
InstallTrueMethod( IsGroup, IsPolycyclicGroup );
InstallTrueMethod( IsSolvableGroup, IsPolycyclicGroup );
InstallTrueMethod( IsPolycyclicGroup, IsSolvableGroup and IsFinite );
InstallTrueMethod( IsPolycyclicGroup,
IsNilpotentGroup and IsFinitelyGeneratedGroup );
#############################################################################
##
#A AbelianInvariants( <G> )
##
## <#GAPDoc Label="AbelianInvariants:grp">
## <ManSection>
## <Attr Name="AbelianInvariants" Arg='G'/>
##
## <Description>
## <Index Subkey="for groups" Key="AbelianInvariants">
## <C>AbelianInvariants</C></Index>
## returns the abelian invariants (also sometimes called primary
## decomposition) of the commutator factor group of the
## group <A>G</A>. These are given as a list of prime-powers or zeroes and
## describe the structure of <M><A>G</A>/<A>G</A>'</M> as a direct product
## of cyclic groups of prime power (or infinite) order.
## <P/>
## (See <Ref Attr="IndependentGeneratorsOfAbelianGroup"/> to obtain actual
## generators).
## <Example><![CDATA[
## gap> g:=Group((1,2,3,4),(1,2),(5,6));;
## gap> AbelianInvariants(g);
## [ 2, 2 ]
## gap> h:=FreeGroup(2);;h:=h/[h.1^3];;
## gap> AbelianInvariants(h);
## [ 0, 3 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "AbelianInvariants", IsGroup );
# minimal number of generators for abelianization. Used internally to check
# whether it is worth to attempt to reduce generator number
DeclareAttribute( "AbelianRank", IsGroup );
#############################################################################
##
#A IsInfiniteAbelianizationGroup( <G> )
##
## <#GAPDoc Label="IsInfiniteAbelianizationGroup:grp">
## <ManSection>
## <Prop Name="IsInfiniteAbelianizationGroup" Arg='G'/>
##
## <Description>
## <Index Subkey="for groups" Key="IsInfiniteAbelianizationGroup">
## <C>IsInfiniteAbelianizationGroup</C></Index>
## returns true if the commutator factor group <M><A>G</A>/<A>G</A>'</M> is
## infinite. This might be done without computing the full structure of the
## commutator factor group.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsInfiniteAbelianizationGroup", IsGroup );
# finite groups never have infinite abelianization
InstallTrueMethod( HasIsInfiniteAbelianizationGroup, IsGroup and IsFinite );
#InstallTrueMethod( IsInfiniteAbelianizationGroup, IsSolvableGroup and IsTorsionFree );
#############################################################################
##
#A AsGroup( <D> ) . . . . . . . . . . . . . collection <D>, viewed as group
##
## <#GAPDoc Label="AsGroup">
## <ManSection>
## <Attr Name="AsGroup" Arg='D'/>
##
## <Description>
## if the elements of the collection <A>D</A> form a group the command returns
## this group, otherwise it returns <K>fail</K>.
## <Example><![CDATA[
## gap> AsGroup([(1,2)]);
## fail
## gap> AsGroup([(),(1,2)]);
## Group([ (1,2) ])
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "AsGroup", IsCollection );
#############################################################################
##
#A ChiefSeries( <G> )
##
## <#GAPDoc Label="ChiefSeries">
## <ManSection>
## <Attr Name="ChiefSeries" Arg='G'/>
##
## <Description>
## is a series of normal subgroups of <A>G</A> which cannot be refined
## further.
## That is there is no normal subgroup <M>N</M> of <A>G</A> with
## <M>U_i > N > U_{{i+1}}</M>.
## This attribute returns <E>one</E> chief series (of potentially many
## possibilities).
## <Example><![CDATA[
## gap> g:=Group((1,2,3,4),(1,2));;
## gap> ChiefSeries(g);
## [ Group([ (1,2,3,4), (1,2) ]),
## Group([ (2,4,3), (1,4)(2,3), (1,3)(2,4) ]),
## Group([ (1,4)(2,3), (1,3)(2,4) ]), Group(()) ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "ChiefSeries", IsGroup );
#############################################################################
##
#O ChiefSeriesUnderAction( <H>, <G> )
##
## <#GAPDoc Label="ChiefSeriesUnderAction">
## <ManSection>
## <Oper Name="ChiefSeriesUnderAction" Arg='H, G'/>
##
## <Description>
## returns a series of normal subgroups of <A>G</A> which are invariant under
## <A>H</A> such that the series cannot be refined any further.
## <A>G</A> must be a subgroup of <A>H</A>.
## This attribute returns <E>one</E> such series (of potentially many
## possibilities).
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "ChiefSeriesUnderAction", [ IsGroup, IsGroup ] );
#############################################################################
##
#O ChiefSeriesThrough( <G>, <l> )
##
## <#GAPDoc Label="ChiefSeriesThrough">
## <ManSection>
## <Oper Name="ChiefSeriesThrough" Arg='G, l'/>
##
## <Description>
## is a chief series of the group <A>G</A> going through
## the normal subgroups in the list <A>l</A>, which must be a list of normal
## subgroups of <A>G</A> contained in each other, sorted by descending size.
## This attribute returns <E>one</E>
## chief series (of potentially many possibilities).
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "ChiefSeriesThrough", [ IsGroup, IsList ] );
#############################################################################
##
#F RefinedSubnormalSeries( <ser>, <n> )
##
## <#GAPDoc Label="RefinedSubnormalSeries">
## <ManSection>
## <Oper Name="RefinedSubnormalSeries" Arg='ser,n'/>
##
## <Description>
## If <A>ser</A> is a subnormal series of a group <A>G</A>, and <A>n</A> is a
## normal subgroup, this function returns the series obtained by refining with
## <A>n</A>, that is closures and intersections are inserted at the appropriate
## place.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "RefinedSubnormalSeries" );
#############################################################################
##
#A CommutatorFactorGroup( <G> )
##
## <#GAPDoc Label="CommutatorFactorGroup">
## <ManSection>
## <Attr Name="CommutatorFactorGroup" Arg='G'/>
##
## <Description>
## computes the commutator factor group <M><A>G</A>/<A>G</A>'</M> of the group <A>G</A>.
## <Example><![CDATA[
## gap> CommutatorFactorGroup(g);
## Group([ f1 ])
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "CommutatorFactorGroup", IsGroup );
#############################################################################
##
#A CompositionSeries( <G> )
#A CompositionSeriesThrough( <G>, <normals> )
##
## <#GAPDoc Label="CompositionSeries">
## <ManSection>
## <Attr Name="CompositionSeries" Arg='G'/>
## <Oper Name="CompositionSeriesThrough" Arg='G, normals'/>
##
## <Description>
## A composition series is a subnormal series which cannot be refined.
## This attribute returns <E>one</E> composition series (of potentially many
## possibilities). The variant <Ref Oper="CompositionSeriesThrough"/> takes
## as second argument a list <A>normals</A> of normal subgroups of the
## group, and returns a composition series that incorporates these normal
## subgroups.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "CompositionSeries", IsGroup );
DeclareOperation( "CompositionSeriesThrough", [IsGroup,IsList] );
#T and for module?
#############################################################################
##
#F DisplayCompositionSeries( <G> )
##
## <#GAPDoc Label="DisplayCompositionSeries">
## <ManSection>
## <Func Name="DisplayCompositionSeries" Arg='G'/>
##
## <Description>
## Displays a composition series of <A>G</A> in a nice way, identifying the
## simple factors.
## <Example><![CDATA[
## gap> CompositionSeries(g);
## [ Group([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ]),
## Group([ (2,4,3), (1,4)(2,3), (1,3)(2,4) ]),
## Group([ (1,4)(2,3), (1,3)(2,4) ]), Group([ (1,3)(2,4) ]), Group(())
## ]
## gap> DisplayCompositionSeries(Group((1,2,3,4,5,6,7),(1,2)));
## G (2 gens, size 5040)
## | C2
## S (5 gens, size 2520)
## | A7
## 1 (0 gens, size 1)
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "DisplayCompositionSeries" );
#############################################################################
##
#A ConjugacyClasses( <G> )
##
## <#GAPDoc Label="ConjugacyClasses:grp">
## <ManSection>
## <Attr Name="ConjugacyClasses" Arg='G' Label="attribute"/>
##
## <Description>
## returns the conjugacy classes of elements of <A>G</A> as a list of
## class objects of <A>G</A>
## (see <Ref Oper="ConjugacyClass"/> for details).
## It is guaranteed that the class of the
## identity is in the first position, the further arrangement depends on
## the method chosen (and might be different for equal but not identical
## groups).
## <P/>
## For very small groups (of size up to 500) the classes will be computed
## by the conjugation action of <A>G</A> on itself
## (see <Ref Func="ConjugacyClassesByOrbits"/>).
## This can be deliberately switched off using the <Q><C>noaction</C></Q>
## option shown below.
## <P/>
## For solvable groups, the default method to compute the classes is by
## homomorphic lift
## (see section <Ref Sect="Conjugacy Classes in Solvable Groups"/>).
## <P/>
## For other groups the method of <Cite Key="HulpkeClasses"/> is employed.
## <P/>
## <Ref Attr="ConjugacyClasses" Label="attribute"/> supports the following
## options that can be used to modify this strategy:
## <List>
## <Mark><C>random</C></Mark>
## <Item>
## The classes are computed by random search.
## See <Ref Func="ConjugacyClassesByRandomSearch"/> below.
## </Item>
## <Mark><C>action</C></Mark>
## <Item>
## The classes are computed by action of <A>G</A> on itself.
## See <Ref Func="ConjugacyClassesByOrbits"/> below.
## </Item>
## <Mark><C>noaction</C></Mark>
## <Item>
## Even for small groups
## <Ref Func="ConjugacyClassesByOrbits"/>
## is not used as a default. This can be useful if the elements of the
## group use a lot of memory.
## </Item>
## </List>
## <Example><![CDATA[
## gap> g:=SymmetricGroup(4);;
## gap> cl:=ConjugacyClasses(g);
## [ ()^G, (1,2)^G, (1,2)(3,4)^G, (1,2,3)^G, (1,2,3,4)^G ]
## gap> Representative(cl[3]);Centralizer(cl[3]);
## (1,2)(3,4)
## Group([ (1,2), (1,3)(2,4), (3,4) ])
## gap> Size(Centralizer(cl[5]));
## 4
## gap> Size(cl[2]);
## 6
## ]]></Example>
## <P/>
## In general, you will not need to have to influence the method, but simply
## call <Ref Attr="ConjugacyClasses" Label="attribute"/>
## –&GAP; will try to select a suitable method on its own.
## The method specifications are provided here mainly for expert use.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "ConjugacyClasses", IsGroup );
#############################################################################
##
#A ConjugacyClassesMaximalSubgroups( <G> )
##
## <#GAPDoc Label="ConjugacyClassesMaximalSubgroups">
## <ManSection>
## <Attr Name="ConjugacyClassesMaximalSubgroups" Arg='G'/>
##
## <Description>
## returns the conjugacy classes of maximal subgroups of <A>G</A>.
## Representatives of the classes can be computed directly by
## <Ref Attr="MaximalSubgroupClassReps"/>.
## <Example><![CDATA[
## gap> ConjugacyClassesMaximalSubgroups(g);
## [ Group( [ (2,4,3), (1,4)(2,3), (1,3)(2,4) ] )^G,
## Group( [ (3,4), (1,3)(2,4) ] )^G, Group( [ (3,4), (2,4,3) ] )^G ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "ConjugacyClassesMaximalSubgroups", IsGroup );
#############################################################################
##
#A MaximalSubgroups( <G> )
##
## <#GAPDoc Label="MaximalSubgroups">
## <ManSection>
## <Attr Name="MaximalSubgroups" Arg='G'/>
##
## <Description>
## returns a list of all maximal subgroups of <A>G</A>. This may take up much
## space, therefore the command should be avoided if possible. See
## <Ref Attr="ConjugacyClassesMaximalSubgroups"/>.
## <Example><![CDATA[
## gap> MaximalSubgroups(Group((1,2,3),(1,2)));
## [ Group([ (1,2,3) ]), Group([ (2,3) ]), Group([ (1,2) ]),
## Group([ (1,3) ]) ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "MaximalSubgroups", IsGroup );
#############################################################################
##
#A MaximalSubgroupClassReps( <G> )
##
## <#GAPDoc Label="MaximalSubgroupClassReps">
## <ManSection>
## <Attr Name="MaximalSubgroupClassReps" Arg='G'/>
##
## <Description>
## returns a list of conjugacy representatives of the maximal subgroups
## of <A>G</A>.
## <Example><![CDATA[
## gap> MaximalSubgroupClassReps(g);
## [ Group([ (2,4,3), (1,4)(2,3), (1,3)(2,4) ]),
## Group([ (3,4), (1,3)(2,4) ]), Group([ (3,4), (2,4,3) ]) ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute("MaximalSubgroupClassReps",IsGroup);
# functions to calculate maximal subgroups (or fail if not possible)
DeclareOperation("CalcMaximalSubgroupClassReps",[IsGroup]);
DeclareGlobalFunction("TryMaximalSubgroupClassReps");
# utility attribute: Allow use with limiting options, so could hold `fail'.
DeclareAttribute("StoredPartialMaxSubs",IsGroup,"mutable");
# utility function in maximal subgroups code
DeclareGlobalFunction("DoMaxesTF");
# make this an operation to allow for overloading and TryNextMethod();
DeclareOperation("MaxesAlmostSimple",[IsGroup]);
#############################################################################
##
#F MaximalPropertySubgroups( <G>, <prop> )
##
## <#GAPDoc Label="MaximalPropertySubgroups">
## <ManSection>
## <Func Name="MaximalPropertySubgroups" Arg='G,prop'/>
##
## <Description>
## For a function <A>prop</A> that tests for a property that persists
## under taking subgroups, this function returns conjugacy class
## representatives of the subgroups of <A>G</A> that are maximal subject to
## this property.
## <Example><![CDATA[
## gap> max:=MaximalPropertySubgroups(AlternatingGroup(8),IsNilpotent);;
## gap> List(max,Size);
## [ 64, 15, 12, 9, 7, 6 ]
## gap> max:=MaximalSolvableSubgroups(AlternatingGroup(10));;
## gap> List(max,Size);
## [ 1152, 864, 648, 576, 400, 384, 320, 216, 126, 240, 168, 120 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction("MaximalPropertySubgroups");
DeclareGlobalFunction("MaximalSolvableSubgroups");
#############################################################################
##
#A PerfectResiduum( <G> )
##
## <#GAPDoc Label="PerfectResiduum">
## <ManSection>
## <Attr Name="PerfectResiduum" Arg='G'/>
##
## <Description>
## is the smallest normal subgroup of <A>G</A> that has a solvable factor group.
## <Example><![CDATA[
## gap> PerfectResiduum(SymmetricGroup(5));
## Alt( [ 1 .. 5 ] )
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "PerfectResiduum", IsGroup );
#############################################################################
##
#A RepresentativesPerfectSubgroups( <G> )
#A RepresentativesSimpleSubgroups( <G> )
##
## <#GAPDoc Label="RepresentativesPerfectSubgroups">
## <ManSection>
## <Attr Name="RepresentativesPerfectSubgroups" Arg='G'/>
## <Attr Name="RepresentativesSimpleSubgroups" Arg='G'/>
##
## <Description>
## returns a list of conjugacy representatives of perfect (respectively
## simple) subgroups of <A>G</A>.
## This uses the library of perfect groups
## (see <Ref Func="PerfectGroup" Label="for group order (and index)"/>),
## thus it will issue an error if the library is insufficient to determine
## all perfect subgroups.
## <Example><![CDATA[
## gap> m11:=TransitiveGroup(11,6);
## M(11)
## gap> r:=RepresentativesPerfectSubgroups(m11);;
## gap> List(r,Size);
## [ 60, 60, 360, 660, 7920, 1 ]
## gap> List(r,StructureDescription);
## [ "A5", "A5", "A6", "PSL(2,11)", "M11", "1" ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "RepresentativesPerfectSubgroups", IsGroup );
DeclareAttribute( "RepresentativesSimpleSubgroups", IsGroup );
#############################################################################
##
#A ConjugacyClassesPerfectSubgroups( <G> )
##
## <#GAPDoc Label="ConjugacyClassesPerfectSubgroups">
## <ManSection>
## <Attr Name="ConjugacyClassesPerfectSubgroups" Arg='G'/>
##
## <Description>
## returns a list of the conjugacy classes of perfect subgroups of <A>G</A>.
## (see <Ref Attr="RepresentativesPerfectSubgroups"/>.)
## <Example><![CDATA[
## gap> r := ConjugacyClassesPerfectSubgroups(m11);;
## gap> List(r, x -> StructureDescription(Representative(x)));
## [ "A5", "A5", "A6", "PSL(2,11)", "M11", "1" ]
## gap> SortedList( List(r,Size) );
## [ 1, 1, 11, 12, 66, 132 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "ConjugacyClassesPerfectSubgroups", IsGroup );
#############################################################################
##
#A ConjugacyClassesSubgroups( <G> )
##
## <#GAPDoc Label="ConjugacyClassesSubgroups">
## <ManSection>
## <Attr Name="ConjugacyClassesSubgroups" Arg='G'/>
##
## <Description>
## This attribute returns a list of all conjugacy classes of subgroups of
## the group <A>G</A>.
## It also is applicable for lattices of subgroups (see <Ref Attr="LatticeSubgroups"/>).
## The order in which the classes are listed depends on the method chosen by
## &GAP;.
## For each class of subgroups, a representative can be accessed using
## <Ref Attr="Representative"/>.
## <Example><![CDATA[
## gap> ConjugacyClassesSubgroups(g);
## [ Group( () )^G, Group( [ (1,3)(2,4) ] )^G, Group( [ (3,4) ] )^G,
## Group( [ (2,4,3) ] )^G, Group( [ (1,4)(2,3), (1,3)(2,4) ] )^G,
## Group( [ (3,4), (1,2)(3,4) ] )^G,
## Group( [ (1,3,2,4), (1,2)(3,4) ] )^G, Group( [ (3,4), (2,4,3) ] )^G,
## Group( [ (1,4)(2,3), (1,3)(2,4), (3,4) ] )^G,
## Group( [ (1,4)(2,3), (1,3)(2,4), (2,4,3) ] )^G,
## Group( [ (1,4)(2,3), (1,3)(2,4), (2,4,3), (3,4) ] )^G ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "ConjugacyClassesSubgroups", IsGroup );
#############################################################################
##
#A LatticeSubgroups( <G> )
##
## <#GAPDoc Label="LatticeSubgroups">
## <ManSection>
## <Attr Name="LatticeSubgroups" Arg='G'/>
##
## <Description>
## computes the lattice of subgroups of the group <A>G</A>. This lattice has
## the conjugacy classes of subgroups as attribute
## <Ref Attr="ConjugacyClassesSubgroups"/> and
## permits one to test maximality/minimality relations.
## <Example><![CDATA[
## gap> g:=SymmetricGroup(4);;
## gap> l:=LatticeSubgroups(g);
## <subgroup lattice of Sym( [ 1 .. 4 ] ), 11 classes, 30 subgroups>
## gap> ConjugacyClassesSubgroups(l);
## [ Group( () )^G, Group( [ (1,3)(2,4) ] )^G, Group( [ (3,4) ] )^G,
## Group( [ (2,4,3) ] )^G, Group( [ (1,4)(2,3), (1,3)(2,4) ] )^G,
## Group( [ (3,4), (1,2)(3,4) ] )^G,
## Group( [ (1,3,2,4), (1,2)(3,4) ] )^G, Group( [ (3,4), (2,4,3) ] )^G,
## Group( [ (1,4)(2,3), (1,3)(2,4), (3,4) ] )^G,
## Group( [ (1,4)(2,3), (1,3)(2,4), (2,4,3) ] )^G,
## Group( [ (1,4)(2,3), (1,3)(2,4), (2,4,3), (3,4) ] )^G ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "LatticeSubgroups", IsGroup );
#############################################################################
##
#A DerivedLength( <G> )
##
## <#GAPDoc Label="DerivedLength">
## <ManSection>
## <Attr Name="DerivedLength" Arg='G'/>
##
## <Description>
## The derived length of a group is the number of steps in the derived
## series. (As there is always the group, it is the series length minus 1.)
## <Example><![CDATA[
## gap> List(DerivedSeriesOfGroup(g),Size);
## [ 24, 12, 4, 1 ]
## gap> DerivedLength(g);
## 3
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "DerivedLength", IsGroup );
#############################################################################
##
#A HirschLength( <G> )
##
## <ManSection>
## <Attr Name="HirschLength" Arg='G'/>
##
## <Description>
## Suppose that <A>G</A> is polycyclic-by-finite; that is, there exists a
## polycyclic normal subgroup N in <A>G</A> with [G : N] finite. Then the Hirsch
## length of <A>G</A> is the number of infinite cyclic factors in a polycyclic
## series of N. This is an invariant of <A>G</A>.
## </Description>
## </ManSection>
##
DeclareAttribute( "HirschLength", IsGroup );
InstallIsomorphismMaintenance( HirschLength, IsGroup, IsGroup );
#############################################################################
##
#A DerivedSeriesOfGroup( <G> )
##
## <#GAPDoc Label="DerivedSeriesOfGroup">
## <ManSection>
## <Attr Name="DerivedSeriesOfGroup" Arg='G'/>
##
## <Description>
## The derived series of a group is obtained by <M>U_{{i+1}} = U_i'</M>.
## It stops if <M>U_i</M> is perfect.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "DerivedSeriesOfGroup", IsGroup );
#############################################################################
##
#A DerivedSubgroup( <G> )
##
## <#GAPDoc Label="DerivedSubgroup">
## <ManSection>
## <Attr Name="DerivedSubgroup" Arg='G'/>
##
## <Description>
## The derived subgroup <M><A>G</A>'</M> of <A>G</A> is the subgroup
## generated by all commutators of pairs of elements of <A>G</A>.
## It is normal in <A>G</A> and the factor group <M><A>G</A>/<A>G</A>'</M>
## is the largest abelian factor group of <A>G</A>.
## <Example><![CDATA[
## gap> g:=Group((1,2,3,4),(1,2));;
## gap> DerivedSubgroup(g) = Group([ (1,3,2), (2,4,3) ]);
## true
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "DerivedSubgroup", IsGroup );
#############################################################################
##
#A MaximalAbelianQuotient( <G> ) . . . . Max abelian quotient
##
## <#GAPDoc Label="MaximalAbelianQuotient">
## <ManSection>
## <Attr Name="MaximalAbelianQuotient" Arg='G'/>
##
## <Description>
## returns an epimorphism from <A>G</A> onto the maximal abelian quotient of
## <A>G</A>.
## The kernel of this epimorphism is the derived subgroup of <A>G</A>,
## see <Ref Attr="DerivedSubgroup"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "MaximalAbelianQuotient",IsGroup);
#############################################################################
##
#A CommutatorLength( <G> )
##
## <#GAPDoc Label="CommutatorLength">
## <ManSection>
## <Attr Name="CommutatorLength" Arg='G'/>
##
## <Description>
## returns the minimal number <M>n</M> such that each element
## in the derived subgroup (see <Ref Attr="DerivedSubgroup"/>) of the
## group <A>G</A> can be written as a product of (at most) <M>n</M>
## commutators of elements in <A>G</A>.
## <Example><![CDATA[
## gap> CommutatorLength( g );
## 1
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "CommutatorLength", IsGroup );
#############################################################################
##
#A DimensionsLoewyFactors( <G> )
##
## <#GAPDoc Label="DimensionsLoewyFactors">
## <ManSection>
## <Attr Name="DimensionsLoewyFactors" Arg='G'/>
##
## <Description>
## This operation computes the dimensions of the factors of the Loewy
## series of <A>G</A>.
## (See <Cite Key="Hup82" Where="p. 157"/> for the slightly complicated
## definition of the Loewy Series.)
## <P/>
## The dimensions are computed via the <Ref Attr="JenningsSeries"/> without computing
## the Loewy series itself.
## <Example><![CDATA[
## gap> G:= SmallGroup( 3^6, 100 );
## <pc group of size 729 with 6 generators>
## gap> JenningsSeries( G );
## [ <pc group of size 729 with 6 generators>, Group([ f3, f4, f5, f6 ]),
## Group([ f4, f5, f6 ]), Group([ f5, f6 ]), Group([ f5, f6 ]),
## Group([ f5, f6 ]), Group([ f6 ]), Group([ f6 ]), Group([ f6 ]),
## Group([ <identity> of ... ]) ]
## gap> DimensionsLoewyFactors(G);
## [ 1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20, 22, 23, 25, 26,
## 27, 27, 27, 27, 27, 27, 27, 27, 27, 26, 25, 23, 22, 20, 19, 17, 16,
## 14, 13, 11, 10, 8, 7, 5, 4, 2, 1 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "DimensionsLoewyFactors", IsGroup );
#############################################################################
##
#A ElementaryAbelianSeries( <G> )
#A ElementaryAbelianSeriesLargeSteps( <G> )
#A ElementaryAbelianSeries( [<G>,<NT1>,<NT2>,...] )
##
## <#GAPDoc Label="ElementaryAbelianSeries">
## <ManSection>
## <Heading>ElementaryAbelianSeries</Heading>
## <Attr Name="ElementaryAbelianSeries" Arg='G' Label="for a group"/>
## <Attr Name="ElementaryAbelianSeriesLargeSteps" Arg='G'/>
## <Attr Name="ElementaryAbelianSeries" Arg='list' Label="for a list"/>
##
## <Description>
## returns a series of normal subgroups of <M>G</M> such that all factors are
## elementary abelian. If the group is not solvable (and thus no such series
## exists) it returns <K>fail</K>.
## <P/>
## The variant <Ref Attr="ElementaryAbelianSeriesLargeSteps"/> tries to make
## the steps in this series large (by eliminating intermediate subgroups if
## possible) at a small additional cost.
## <P/>
## In the third variant, an elementary abelian series through the given
## series of normal subgroups in the list <A>list</A> is constructed.
## <Example><![CDATA[
## gap> List(ElementaryAbelianSeries(g),Size);
## [ 24, 12, 4, 1 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "ElementaryAbelianSeries", IsGroup );
DeclareAttribute( "ElementaryAbelianSeriesLargeSteps", IsGroup );
#############################################################################
##
#A Exponent( <G> )
##
## <#GAPDoc Label="Exponent">
## <ManSection>
## <Attr Name="Exponent" Arg='G'/>
##
## <Description>
## The exponent <M>e</M> of a group <A>G</A> is the lcm of the orders of its
## elements, that is, <M>e</M> is the smallest integer such that
## <M>g^e = 1</M> for all <M>g \in <A>G</A></M>.
## <Example><![CDATA[
## gap> Exponent(g);
## 12
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "Exponent", IsGroup );
InstallIsomorphismMaintenance( Exponent, IsGroup, IsGroup );
#############################################################################
##
#A FittingSubgroup( <G> )
##
## <#GAPDoc Label="FittingSubgroup">
## <ManSection>
## <Attr Name="FittingSubgroup" Arg='G'/>
##
## <Description>
## The Fitting subgroup of a group <A>G</A> is its largest nilpotent normal
## subgroup.
## <Example><![CDATA[
## gap> FittingSubgroup(g);
## Group([ (1,2)(3,4), (1,4)(2,3) ])
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "FittingSubgroup", IsGroup );
#############################################################################
##
#A PrefrattiniSubgroup( <G> )
##
## <#GAPDoc Label="PrefrattiniSubgroup">
## <ManSection>
## <Attr Name="PrefrattiniSubgroup" Arg='G'/>
##
## <Description>
## returns a Prefrattini subgroup of the finite solvable group <A>G</A>.
## <P/>
## A factor <M>M/N</M> of <A>G</A> is called a Frattini factor if
## <M>M/N</M> is contained in the Frattini subgroup of <M><A>G</A>/N</M>.
## A subgroup <M>P</M> is a Prefrattini subgroup of <A>G</A> if <M>P</M>
## covers each Frattini chief factor of <A>G</A>, and if for each maximal
## subgroup of <A>G</A> there exists a conjugate maximal subgroup, which
## contains <M>P</M>.
## In a finite solvable group <A>G</A> the Prefrattini subgroups
## form a characteristic conjugacy class of subgroups and the intersection
## of all these subgroups is the Frattini subgroup of <A>G</A>.
## <Example><![CDATA[
## gap> G := SmallGroup( 60, 7 );
## <pc group of size 60 with 4 generators>
## gap> P := PrefrattiniSubgroup(G);
## Group([ f2 ])
## gap> Size(P);
## 2
## gap> IsNilpotent(P);
## true
## gap> Core(G,P);
## Group([ ])
## gap> FrattiniSubgroup(G);
## Group([ ])
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "PrefrattiniSubgroup", IsGroup );
#############################################################################
##
#A FrattiniSubgroup( <G> )
##
## <#GAPDoc Label="FrattiniSubgroup">
## <ManSection>
## <Attr Name="FrattiniSubgroup" Arg='G'/>
##
## <Description>
## The Frattini subgroup of a group <A>G</A> is the intersection of all
## maximal subgroups of <A>G</A>.
## <Example><![CDATA[
## gap> FrattiniSubgroup(g);
## Group(())
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "FrattiniSubgroup", IsGroup );
#############################################################################
##
#A InvariantForm( <D> )
##
## <ManSection>
## <Attr Name="InvariantForm" Arg='D'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareAttribute( "InvariantForm", IsGroup );
#############################################################################
##
#A JenningsSeries( <G> )
##
## <#GAPDoc Label="JenningsSeries">
## <ManSection>
## <Attr Name="JenningsSeries" Arg='G'/>
##
## <Description>
## For a <M>p</M>-group <A>G</A>, this function returns its Jennings series.
## This series is defined by setting
## <M>G_1 = <A>G</A></M> and for <M>i \geq 0</M>,
## <M>G_{{i+1}} = [G_i,<A>G</A>] G_j^p</M>,
## where <M>j</M> is the smallest integer <M>> i/p</M>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "JenningsSeries", IsGroup );
#############################################################################
##
#A LowerCentralSeriesOfGroup( <G> )
##
## <#GAPDoc Label="LowerCentralSeriesOfGroup">
## <ManSection>
## <Attr Name="LowerCentralSeriesOfGroup" Arg='G'/>
##
## <Description>
## The lower central series of a group <A>G</A> is defined as
## <M>U_{{i+1}}:= [<A>G</A>, U_i]</M>.
## It is a central series of normal subgroups.
## The name derives from the fact that <M>U_i</M> is contained in the
## <M>i</M>-th step subgroup of any central series.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "LowerCentralSeriesOfGroup", IsGroup );
#############################################################################
##
#A NilpotencyClassOfGroup( <G> )
##
## <#GAPDoc Label="NilpotencyClassOfGroup">
## <ManSection>
## <Attr Name="NilpotencyClassOfGroup" Arg='G'/>
##
## <Description>
## The nilpotency class of a nilpotent group <A>G</A> is the number of steps in
## the lower central series of <A>G</A> (see <Ref Attr="LowerCentralSeriesOfGroup"/>);
## <P/>
## If <A>G</A> is not nilpotent an error is issued.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "NilpotencyClassOfGroup", IsGroup );
#############################################################################
##
#A MaximalNormalSubgroups( <G> )
##
## <#GAPDoc Label="MaximalNormalSubgroups">
## <ManSection>
## <Attr Name="MaximalNormalSubgroups" Arg='G'/>
##
## <Description>
## is a list containing those proper normal subgroups of the group <A>G</A>
## that are maximal among the proper normal subgroups. Gives error if
## <A>G</A>/<A>G'</A> is infinite, yielding infinitely many maximal normal
## subgroups.
##
## Note, that the maximal normal subgroups of a group <A>G</A> can be
## computed more efficiently if the character table of <A>G</A> is known or
## if <A>G</A> is known to be abelian or solvable (even if infinite). So if
## the character table is needed, anyhow, or <A>G</A> is suspected to be
## abelian or solvable, then these should be computed before computing the
## maximal normal subgroups.
## <Example><![CDATA[
## gap> g:=SymmetricGroup(4);; MaximalNormalSubgroups( g );
## [ Alt( [ 1 .. 4 ] ) ]
## gap> f := FreeGroup("x", "y");; x := f.1;; y := f.2;;
## gap> List(MaximalNormalSubgroups(f/[x^2, y^2]), GeneratorsOfGroup);
## [ [ x, y*x*y^-1 ], [ y, x*y*x^-1 ], [ y*x^-1 ] ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "MaximalNormalSubgroups", IsGroup );
#############################################################################
##
#A NormalMaximalSubgroups( <G> )
##
## <ManSection>
## <Attr Name="NormalMaximalSubgroups" Arg='G'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareAttribute( "NormalMaximalSubgroups", IsGroup );
#############################################################################
##
#A MinimalNormalSubgroups( <G> )
##
## <#GAPDoc Label="MinimalNormalSubgroups">
## <ManSection>
## <Attr Name="MinimalNormalSubgroups" Arg='G'/>
##
## <Description>
## is a list containing those nontrivial normal subgroups of the group <A>G</A>
## that are minimal among the nontrivial normal subgroups.
## <Example><![CDATA[
## gap> g:=SymmetricGroup(4);; MinimalNormalSubgroups( g );
## [ Group([ (1,4)(2,3), (1,3)(2,4) ]) ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "MinimalNormalSubgroups", IsGroup );
#############################################################################
##
#A NormalSubgroups( <G> )
##
## <#GAPDoc Label="NormalSubgroups">
## <ManSection>
## <Attr Name="NormalSubgroups" Arg='G'/>
##
## <Description>
## returns a list of all normal subgroups of <A>G</A>.
## <Example><![CDATA[
## gap> g:=SymmetricGroup(4);;
## gap> List( NormalSubgroups(g), StructureDescription );
## [ "S4", "A4", "C2 x C2", "1" ]
## gap> g:=AbelianGroup([2,2]);; NormalSubgroups(g);
## [ <pc group of size 4 with 2 generators>, Group([ f2 ]),
## Group([ f1*f2 ]), Group([ f1 ]), Group([ ]) ]
## ]]></Example>
## <P/>
--> --------------------
--> maximum size reached
--> --------------------
[ Dauer der Verarbeitung: 0.54 Sekunden
(vorverarbeitet)
]
|
