|
#############################################################################
##
## This file is part of GAP, a system for computational discrete algebra.
## This file's authors include Frank Celler.
##
## 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 operations for polycyclic generating systems.
##
#############################################################################
##
#C IsGeneralPcgs(<obj>)
##
## <ManSection>
## <Filt Name="IsGeneralPcgs" Arg='obj' Type='Category'/>
##
## <Description>
## The category of general pcgs. Each modulo pcgs is a general pcgs.
## Relative orders are known for general pcgs, but it might not be possible
## to compute exponent vectors or other elementary operations with respect
## to a general pcgs. (For performance reasons immediate methods are always
## ignored for Pcgs.)
## </Description>
## </ManSection>
##
DeclareCategory( "IsGeneralPcgs",
IsHomogeneousList and IsDuplicateFreeList and IsConstantTimeAccessList
and IsFinite and IsMultiplicativeElementWithInverseCollection
and IsNoImmediateMethodsObject);
#############################################################################
##
#C IsModuloPcgs(<obj>)
##
## <#GAPDoc Label="IsModuloPcgs">
## <ManSection>
## <Filt Name="IsModuloPcgs" Arg='obj' Type='Category'/>
##
## <Description>
## The category of modulo pcgs. Note that each pcgs is a modulo pcgs for
## the trivial subgroup.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareCategory("IsModuloPcgs",IsGeneralPcgs);
#############################################################################
##
#C IsPcgs(<obj>)
##
## <#GAPDoc Label="IsPcgs">
## <ManSection>
## <Filt Name="IsPcgs" Arg='obj' Type='Category'/>
##
## <Description>
## The category of pcgs.
## <Example><![CDATA[
## gap> G := Group((1,2,3,4),(1,2));;
## gap> p := Pcgs(G);
## Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ])
## gap> IsPcgs( p );
## true
## gap> p[1];
## (3,4)
## gap> G := Group((1,2,3,4,5),(1,2));;
## gap> Pcgs(G);
## fail
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareCategory( "IsPcgs", IsModuloPcgs);
#############################################################################
##
#C IsPcgsFamily
##
## <ManSection>
## <Filt Name="IsPcgsFamily" Arg='obj' Type='Category'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareCategory(
"IsPcgsFamily",
IsFamily );
#############################################################################
##
#R IsPcgsDefaultRep
##
## <ManSection>
## <Filt Name="IsPcgsDefaultRep" Arg='obj' Type='Representation'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareRepresentation(
"IsPcgsDefaultRep",
IsComponentObjectRep and IsAttributeStoringRep, [] );
#############################################################################
##
#O PcgsByPcSequence( <fam>, <pcs> )
#O PcgsByPcSequenceNC( <fam>, <pcs> )
##
## <#GAPDoc Label="PcgsByPcSequence">
## <ManSection>
## <Oper Name="PcgsByPcSequence" Arg='fam, pcs'/>
## <Oper Name="PcgsByPcSequenceNC" Arg='fam, pcs'/>
##
## <Description>
## constructs a pcgs for the elements family <A>fam</A> from the elements in
## the list <A>pcs</A>. The elements must lie in the family <A>fam</A>.
## <Ref Oper="PcgsByPcSequence"/> and its <C>NC</C> variant will always
## create a new pcgs which is not induced by any other pcgs
## (cf. <Ref Oper="InducedPcgsByPcSequence"/>).
## <Example><![CDATA[
## gap> fam := FamilyObj( (1,2) );; # the family of permutations
## gap> p := PcgsByPcSequence( fam, [(1,2),(1,2,3)] );
## Pcgs([ (1,2), (1,2,3) ])
## gap> RelativeOrders(p);
## [ 2, 3 ]
## gap> ExponentsOfPcElement( p, (1,3,2) );
## [ 0, 2 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "PcgsByPcSequence", [ IsFamily, IsList ] );
DeclareOperation( "PcgsByPcSequenceNC", [ IsFamily, IsList ] );
#############################################################################
##
#O PcgsByPcSequenceCons( <req-filters>, <imp-filters>, <fam>, <pcs>,<attr> )
##
## <ManSection>
## <Oper Name="PcgsByPcSequenceCons"
## Arg='req-filters, imp-filters, fam, pcs,attr'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareConstructor( "PcgsByPcSequenceCons",
[ IsObject, IsObject, IsFamily, IsList,IsList ] );
#############################################################################
##
#A PcGroupWithPcgs( <mpcgs> )
##
## <#GAPDoc Label="PcGroupWithPcgs">
## <ManSection>
## <Attr Name="PcGroupWithPcgs" Arg='mpcgs'/>
##
## <Description>
## creates a new pc group <A>G</A> whose family pcgs is isomorphic to the
## (modulo) pcgs <A>mpcgs</A>.
## <Example><![CDATA[
## gap> G := Group( (1,2,3), (3,4,1) );;
## gap> PcGroupWithPcgs( Pcgs(G) );
## <pc group of size 12 with 3 generators>
## ]]></Example>
## <P/>
## If a pcgs is only given by a list of pc elements,
## <Ref Oper="PcgsByPcSequence"/> can be used:
## <Example><![CDATA[
## gap> G:=Group((1,2,3,4),(1,2));;
## gap> p:=PcgsByPcSequence(FamilyObj(One(G)),
## > [ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ]);
## Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ])
## gap> PcGroupWithPcgs(p);
## <pc group of size 24 with 4 generators>
## gap> G := SymmetricGroup( 5 );
## Sym( [ 1 .. 5 ] )
## gap> H := Subgroup( G, [(1,2,3,4,5), (3,4,5)] );
## Group([ (1,2,3,4,5), (3,4,5) ])
## gap> modu := ModuloPcgs( G, H );
## Pcgs([ (4,5) ])
## gap> PcGroupWithPcgs(modu);
## <pc group of size 2 with 1 generator>
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "PcGroupWithPcgs", IsModuloPcgs );
DeclareSynonymAttr( "GroupByPcgs", PcGroupWithPcgs );
#############################################################################
##
#A GroupOfPcgs( <pcgs> )
##
## <#GAPDoc Label="GroupOfPcgs">
## <ManSection>
## <Attr Name="GroupOfPcgs" Arg='pcgs'/>
##
## <Description>
## The group generated by <A>pcgs</A>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute(
"GroupOfPcgs",
IsPcgs );
#############################################################################
##
#A OneOfPcgs( <pcgs> )
##
## <#GAPDoc Label="OneOfPcgs">
## <ManSection>
## <Attr Name="OneOfPcgs" Arg='pcgs'/>
##
## <Description>
## The identity of the group generated by <A>pcgs</A>.
## <Example><![CDATA[
## gap> G := Group( (1,2,3,4),(1,2) );; p := Pcgs(G);;
## gap> RelativeOrders(p);
## [ 2, 3, 2, 2 ]
## gap> IsFiniteOrdersPcgs(p);
## true
## gap> IsPrimeOrdersPcgs(p);
## true
## gap> PcSeries(p);
## [ 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(())
## ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute(
"OneOfPcgs",
IsPcgs );
#############################################################################
##
#A PcSeries( <pcgs> )
##
## <#GAPDoc Label="PcSeries">
## <ManSection>
## <Attr Name="PcSeries" Arg='pcgs'/>
##
## <Description>
## returns the subnormal series determined by <A>pcgs</A>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "PcSeries", IsPcgs );
#############################################################################
##
#P IsPcgsElementaryAbelianSeries( <pcgs> )
##
## <#GAPDoc Label="IsPcgsElementaryAbelianSeries">
## <ManSection>
## <Prop Name="IsPcgsElementaryAbelianSeries" Arg='pcgs'/>
##
## <Description>
## returns <K>true</K> if the pcgs <A>pcgs</A> refines an elementary abelian
## series.
## <Ref Attr="IndicesEANormalSteps"/> then gives the indices in the Pcgs,
## at which the subgroups of this series start.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty("IsPcgsElementaryAbelianSeries", IsPcgs );
#############################################################################
##
#A PcgsElementaryAbelianSeries( <G> )
#A PcgsElementaryAbelianSeries( [<G>,<N1>,<N2>,....])
##
## <#GAPDoc Label="PcgsElementaryAbelianSeries">
## <ManSection>
## <Attr Name="PcgsElementaryAbelianSeries" Arg='G' Label="for a group"/>
## <Attr Name="PcgsElementaryAbelianSeries" Arg='list'
## Label="for a list of normal subgroups"/>
##
## <Description>
## computes a pcgs for <A>G</A> that refines an elementary abelian series.
## <Ref Attr="IndicesEANormalSteps"/> gives the indices in the pcgs,
## at which the normal subgroups of this series start.
## The second variant returns a pcgs that runs through the normal subgroups
## in the list <A>list</A>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "PcgsElementaryAbelianSeries", IsGroup );
#############################################################################
##
#A IndicesEANormalSteps(<pcgs>)
#A IndicesEANormalStepsBounded(<pcgs>,<bound>)
##
## <#GAPDoc Label="IndicesEANormalSteps">
## <ManSection>
## <Attr Name="IndicesEANormalSteps" Arg='pcgs'/>
## <Func Name="IndicesEANormalStepsBounded" Arg='pcgs,bound'/>
##
## <Description>
## Let <A>pcgs</A> be a pcgs obtained as corresponding to a series of normal
## subgroups with elementary abelian factors (for example from calling
## <Ref Attr="PcgsElementaryAbelianSeries" Label="for a group"/>)
## Then <Ref Attr="IndicesEANormalSteps"/> returns a sorted list of
## integers, indicating the tails of <A>pcgs</A> which generate these normal
## subgroup of <A>G</A>.
## If <M>i</M> is an element of this list, <M>(g_i, \ldots, g_n)</M>
## is a normal subgroup of <A>G</A>. The list always starts with <M>1</M>
## and ends with <M>n+1</M>.
## (These indices form <E>one</E> series with elementary abelian
## subfactors, not necessarily the most refined one.)
## <P/>
## The attribute <Ref Attr="EANormalSeriesByPcgs"/> returns the actual
## series of subgroups.
## <P/>
## For arbitrary pcgs not obtained as belonging to a special series such a
## set of indices not necessarily exists,
## and <Ref Attr="IndicesEANormalSteps"/> is not
## guaranteed to work in this situation.
## <P/>
## Typically, <Ref Attr="IndicesEANormalSteps"/> is set by
## <Ref Attr="PcgsElementaryAbelianSeries" Label="for a group"/>.
## <P/>
## The variant <Ref Func="IndicesEANormalStepsBounded"/> will aim to ensure
## that no factor will be larger than the given bound.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "IndicesEANormalSteps", IsPcgs );
DeclareGlobalFunction( "IndicesEANormalStepsBounded" );
#############################################################################
##
#A EANormalSeriesByPcgs(<pcgs>)
##
## <#GAPDoc Label="EANormalSeriesByPcgs">
## <ManSection>
## <Attr Name="EANormalSeriesByPcgs" Arg='pcgs'/>
##
## <Description>
## Let <A>pcgs</A> be a pcgs obtained as corresponding to a series of normal
## subgroups with elementary abelian factors (for example from calling
## <Ref Attr="PcgsElementaryAbelianSeries" Label="for a group"/>).
## This attribute returns the actual series of normal subgroups,
## corresponding to <Ref Attr="IndicesEANormalSteps"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute("EANormalSeriesByPcgs",IsPcgs);
DeclareGlobalFunction( "BoundedRefinementEANormalSeries" );
#############################################################################
##
#P IsPcgsCentralSeries( <pcgs> )
##
## <#GAPDoc Label="IsPcgsCentralSeries">
## <ManSection>
## <Prop Name="IsPcgsCentralSeries" Arg='pcgs'/>
##
## <Description>
## returns <K>true</K> if the pcgs <A>pcgs</A> refines an central elementary
## abelian series.
## <Ref Attr="IndicesCentralNormalSteps"/> then gives the indices in the
## pcgs, at which the subgroups of this series start.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty("IsPcgsCentralSeries", IsPcgs );
#############################################################################
##
#A PcgsCentralSeries( <G> )
##
## <#GAPDoc Label="PcgsCentralSeries">
## <ManSection>
## <Attr Name="PcgsCentralSeries" Arg='G'/>
##
## <Description>
## computes a pcgs for <A>G</A> that refines a central elementary abelian
## series.
## <Ref Attr="IndicesCentralNormalSteps"/> gives the indices in the pcgs,
## at which the normal subgroups of this series start.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "PcgsCentralSeries", IsGroup);
#############################################################################
##
#A IndicesCentralNormalSteps(<pcgs>)
##
## <#GAPDoc Label="IndicesCentralNormalSteps">
## <ManSection>
## <Attr Name="IndicesCentralNormalSteps" Arg='pcgs'/>
##
## <Description>
## Let <A>pcgs</A> be a pcgs obtained as corresponding to a series of normal
## subgroups with central elementary abelian factors
## (for example from calling <Ref Attr="PcgsCentralSeries"/>).
## Then <Ref Attr="IndicesCentralNormalSteps"/> returns a sorted list of
## integers, indicating the tails of <A>pcgs</A> which generate these normal
## subgroups of <A>G</A>.
## If <M>i</M> is an element of this list, <M>(g_i, \ldots, g_n)</M>
## is a normal subgroup of <A>G</A>.
## The list always starts with <M>1</M> and ends with <M>n+1</M>.
## (These indices form <E>one</E> series with central elementary abelian
## subfactors, not necessarily the most refined one.)
## <P/>
## The attribute <Ref Attr="CentralNormalSeriesByPcgs"/> returns the actual
## series of subgroups.
## <P/>
## For arbitrary pcgs not obtained as belonging to a special series such a
## set of indices not necessarily exists,
## and <Ref Attr="IndicesCentralNormalSteps"/>
## is not guaranteed to work in this situation.
## <P/>
## Typically, <Ref Attr="IndicesCentralNormalSteps"/> is set by
## <Ref Attr="PcgsCentralSeries"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "IndicesCentralNormalSteps", IsPcgs );
#############################################################################
##
#A CentralNormalSeriesByPcgs(<pcgs>)
##
## <#GAPDoc Label="CentralNormalSeriesByPcgs">
## <ManSection>
## <Attr Name="CentralNormalSeriesByPcgs" Arg='pcgs'/>
##
## <Description>
## Let <A>pcgs</A> be a pcgs obtained as corresponding to a series of normal
## subgroups with central elementary abelian factors (for example from
## calling <Ref Attr="PcgsCentralSeries"/>).
## This attribute returns the actual series of normal subgroups,
## corresponding to <Ref Attr="IndicesCentralNormalSteps"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute("CentralNormalSeriesByPcgs",IsPcgs);
#############################################################################
##
#P IsPcgsPCentralSeriesPGroup( <pcgs> )
##
## <#GAPDoc Label="IsPcgsPCentralSeriesPGroup">
## <ManSection>
## <Prop Name="IsPcgsPCentralSeriesPGroup" Arg='pcgs'/>
##
## <Description>
## returns <K>true</K> if the pcgs <A>pcgs</A> refines a <M>p</M>-central
## elementary abelian series for a <M>p</M>-group.
## <Ref Attr="IndicesPCentralNormalStepsPGroup"/> then gives the indices in
## the pcgs, at which the subgroups of this series start.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty("IsPcgsPCentralSeriesPGroup", IsPcgs );
#############################################################################
##
#A PcgsPCentralSeriesPGroup( <G> )
##
## <#GAPDoc Label="PcgsPCentralSeriesPGroup">
## <ManSection>
## <Attr Name="PcgsPCentralSeriesPGroup" Arg='G'/>
##
## <Description>
## computes a pcgs for the <M>p</M>-group <A>G</A> that refines a
## <M>p</M>-central elementary abelian series.
## <Ref Attr="IndicesPCentralNormalStepsPGroup"/> gives the
## indices in the pcgs, at which the normal subgroups of this series start.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "PcgsPCentralSeriesPGroup", IsGroup);
#############################################################################
##
#A IndicesPCentralNormalStepsPGroup(<pcgs>)
##
## <#GAPDoc Label="IndicesPCentralNormalStepsPGroup">
## <ManSection>
## <Attr Name="IndicesPCentralNormalStepsPGroup" Arg='pcgs'/>
##
## <Description>
## Let <A>pcgs</A> be a pcgs obtained as corresponding to a series of normal
## subgroups with <M>p</M>-central elementary abelian factors
## (for example from calling <Ref Attr="PcgsPCentralSeriesPGroup"/>).
## Then <Ref Attr="IndicesPCentralNormalStepsPGroup"/> returns a sorted list
## of integers, indicating the tails of <A>pcgs</A> which generate these
## normal subgroups of <A>G</A>.
## If <M>i</M> is an element of this list, <M>(g_i, \ldots, g_n)</M>
## is a normal subgroup of <A>G</A>.
## The list always starts with <M>1</M> and ends with <M>n+1</M>.
## (These indices form <E>one</E> series with central elementary abelian
## subfactors, not necessarily the most refined one.)
## <P/>
## The attribute <Ref Attr="PCentralNormalSeriesByPcgsPGroup"/> returns the
## actual series of subgroups.
## <P/>
## For arbitrary pcgs not obtained as belonging to a special series such a
## set of indices not necessarily exists, and
## <Ref Attr="IndicesPCentralNormalStepsPGroup"/>
## is not guaranteed to work in this situation.
## <P/>
## Typically, <Ref Attr="IndicesPCentralNormalStepsPGroup"/> is set by
## <Ref Attr="PcgsPCentralSeriesPGroup"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "IndicesPCentralNormalStepsPGroup", IsPcgs );
#############################################################################
##
#A PCentralNormalSeriesByPcgsPGroup(<pcgs>)
##
## <#GAPDoc Label="PCentralNormalSeriesByPcgsPGroup">
## <ManSection>
## <Attr Name="PCentralNormalSeriesByPcgsPGroup" Arg='pcgs'/>
##
## <Description>
## Let <A>pcgs</A> be a pcgs obtained as corresponding to a series of normal
## subgroups with <M>p</M>-central elementary abelian factors
## (for example from calling <Ref Attr="PcgsPCentralSeriesPGroup"/>).
## This attribute returns the actual series of normal subgroups,
## corresponding to <Ref Attr="IndicesPCentralNormalStepsPGroup"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute("PCentralNormalSeriesByPcgsPGroup",IsPcgs);
#############################################################################
##
#P IsPcgsChiefSeries( <pcgs> )
##
## <#GAPDoc Label="IsPcgsChiefSeries">
## <ManSection>
## <Prop Name="IsPcgsChiefSeries" Arg='pcgs'/>
##
## <Description>
## returns <K>true</K> if the pcgs <A>pcgs</A> refines a chief series.
## <Ref Attr="IndicesChiefNormalSteps"/> then gives the indices in the pcgs,
## at which the subgroups of this series start.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty("IsPcgsChiefSeries", IsPcgs );
#############################################################################
##
#A PcgsChiefSeries( <G> )
##
## <#GAPDoc Label="PcgsChiefSeries">
## <ManSection>
## <Attr Name="PcgsChiefSeries" Arg='G'/>
##
## <Description>
## computes a pcgs for <A>G</A> that refines a chief series.
## <Ref Attr="IndicesChiefNormalSteps"/> gives the indices in the pcgs,
## at which the normal subgroups of this series start.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "PcgsChiefSeries", IsGroup );
#############################################################################
##
#A IndicesChiefNormalSteps(<pcgs>)
##
## <#GAPDoc Label="IndicesChiefNormalSteps">
## <ManSection>
## <Attr Name="IndicesChiefNormalSteps" Arg='pcgs'/>
##
## <Description>
## Let <A>pcgs</A> be a pcgs obtained as corresponding to a chief series
## for example from calling <Ref Attr="PcgsChiefSeries"/>).
## Then <Ref Attr="IndicesChiefNormalSteps"/> returns a sorted list of
## integers, indicating the tails of <A>pcgs</A> which generate these normal
## subgroups of <A>G</A>.
## If <M>i</M> is an element of this list, <M>(g_i, \ldots, g_n)</M>
## is a normal subgroup of <A>G</A>.
## The list always starts with <M>1</M> and ends with <M>n+1</M>.
## (These indices form <E>one</E> series with elementary abelian
## subfactors, not necessarily the most refined one.)
## <P/>
## The attribute <Ref Attr="ChiefNormalSeriesByPcgs"/> returns the actual
## series of subgroups.
## <P/>
## For arbitrary pcgs not obtained as belonging to a special series such a
## set of indices not necessarily exists,
## and <Ref Attr="IndicesChiefNormalSteps"/> is not
## guaranteed to work in this situation.
## <P/>
## Typically, <Ref Attr="IndicesChiefNormalSteps"/> is set by
## <Ref Attr="PcgsChiefSeries"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "IndicesChiefNormalSteps", IsPcgs );
#############################################################################
##
#A ChiefNormalSeriesByPcgs(<pcgs>)
##
## <#GAPDoc Label="ChiefNormalSeriesByPcgs">
## <ManSection>
## <Attr Name="ChiefNormalSeriesByPcgs" Arg='pcgs'/>
##
## <Description>
## Let <A>pcgs</A> be a pcgs obtained as corresponding to a chief series
## (for example from calling
## <Ref Attr="PcgsChiefSeries"/>). This attribute returns the actual series
## of normal subgroups,
## corresponding to <Ref Attr="IndicesChiefNormalSteps"/>.
##
## <Example><![CDATA[
## gap> g:=Group((1,2,3,4),(1,2));;
## gap> p:=PcgsElementaryAbelianSeries(g);
## Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ])
## gap> IndicesEANormalSteps(p);
## [ 1, 2, 3, 5 ]
## gap> g:=Group((1,2,3,4),(1,5)(2,6)(3,7)(4,8));;
## gap> p:=PcgsCentralSeries(g);
## Pcgs([ (1,5)(2,6)(3,7)(4,8), (5,6,7,8), (5,7)(6,8),
## (1,4,3,2)(5,6,7,8), (1,3)(2,4)(5,7)(6,8) ])
## gap> IndicesCentralNormalSteps(p);
## [ 1, 2, 4, 5, 6 ]
## gap> q:=PcgsPCentralSeriesPGroup(g);
## Pcgs([ (1,5)(2,6)(3,7)(4,8), (5,6,7,8), (5,7)(6,8),
## (1,4,3,2)(5,6,7,8), (1,3)(2,4)(5,7)(6,8) ])
## gap> IndicesPCentralNormalStepsPGroup(q);
## [ 1, 3, 5, 6 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute("ChiefNormalSeriesByPcgs",IsPcgs);
#############################################################################
##
#A IndicesNormalSteps( <pcgs> )
##
## <#GAPDoc Label="IndicesNormalSteps">
## <ManSection>
## <Attr Name="IndicesNormalSteps" Arg='pcgs'/>
##
## <Description>
## returns the indices of <E>all</E> steps in the pc series,
## which are normal in the group defined by the pcgs.
## <P/>
## (In general, this function yields a slower performance than the more
## specialized index functions for elementary abelian series etc.)
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "IndicesNormalSteps", IsPcgs );
#############################################################################
##
#A NormalSeriesByPcgs( <pcgs> )
##
## <#GAPDoc Label="NormalSeriesByPcgs">
## <ManSection>
## <Attr Name="NormalSeriesByPcgs" Arg='pcgs'/>
##
## <Description>
## returns the subgroups the pc series, which are normal in
## the group defined by the pcgs.
## <P/>
## (In general, this function yields a slower performance than the more
## specialized index functions for elementary abelian series etc.)
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "NormalSeriesByPcgs", IsPcgs);
#############################################################################
##
#P IsPrimeOrdersPcgs( <pcgs> )
##
## <#GAPDoc Label="IsPrimeOrdersPcgs">
## <ManSection>
## <Prop Name="IsPrimeOrdersPcgs" Arg='pcgs'/>
##
## <Description>
## tests whether the relative orders of <A>pcgs</A> are prime numbers.
## Many algorithms require a pcgs to have this property.
## The operation <Ref Attr="IsomorphismRefinedPcGroup"/>
## can be of help here.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsPrimeOrdersPcgs", IsGeneralPcgs );
InstallTrueMethod( IsGeneralPcgs, IsPrimeOrdersPcgs );
#############################################################################
##
#P IsFiniteOrdersPcgs( <pcgs> )
##
## <#GAPDoc Label="IsFiniteOrdersPcgs">
## <ManSection>
## <Prop Name="IsFiniteOrdersPcgs" Arg='pcgs'/>
##
## <Description>
## tests whether the relative orders of <A>pcgs</A> are all finite.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareProperty( "IsFiniteOrdersPcgs", IsGeneralPcgs );
InstallTrueMethod( IsGeneralPcgs, IsFiniteOrdersPcgs );
#############################################################################
##
#A RefinedPcGroup( <G> )
##
## <#GAPDoc Label="RefinedPcGroup">
## <ManSection>
## <Attr Name="RefinedPcGroup" Arg='G'/>
##
## <Description>
## returns the range of the <Ref Attr="IsomorphismRefinedPcGroup"/> value of
## <A>G</A>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "RefinedPcGroup", IsPcGroup );
#############################################################################
##
#A IsomorphismRefinedPcGroup( <G> )
##
## <#GAPDoc Label="IsomorphismRefinedPcGroup">
## <ManSection>
## <Attr Name="IsomorphismRefinedPcGroup" Arg='G'/>
##
## <Description>
## <Index Subkey="pc group">isomorphic</Index>
## returns an isomorphism from <A>G</A> onto an isomorphic pc group
## whose family pcgs is a prime order pcgs.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "IsomorphismRefinedPcGroup", IsGroup );
#############################################################################
##
#A RelativeOrders( <pcgs> )
##
## <#GAPDoc Label="RelativeOrders:pcgs">
## <ManSection>
## <Attr Name="RelativeOrders" Arg='pcgs'/>
##
## <Description>
## <Index Subkey="of a pcgs" Key="RelativeOrders">
## <C>RelativeOrders</C></Index>
## returns the list of relative orders of the pcgs <A>pcgs</A>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "RelativeOrders", IsGeneralPcgs );
#############################################################################
##
#O DepthOfPcElement( <pcgs>, <elm> )
##
## <#GAPDoc Label="DepthOfPcElement">
## <ManSection>
## <Oper Name="DepthOfPcElement" Arg='pcgs, elm'/>
##
## <Description>
## returns the depth of the element <A>elm</A> with respect to <A>pcgs</A>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "DepthOfPcElement", [ IsModuloPcgs, IsObject ] );
#############################################################################
##
#O DifferenceOfPcElement( <pcgs>, <left>, <right> )
##
## <ManSection>
## <Oper Name="DifferenceOfPcElement" Arg='pcgs, left, right'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareOperation( "DifferenceOfPcElement", [ IsPcgs, IsObject, IsObject ] );
#############################################################################
##
#O ExponentOfPcElement( <pcgs>, <elm>, <pos> )
##
## <#GAPDoc Label="ExponentOfPcElement">
## <ManSection>
## <Oper Name="ExponentOfPcElement" Arg='pcgs, elm, pos'/>
##
## <Description>
## returns the <A>pos</A>-th exponent of <A>elm</A> with respect to
## <A>pcgs</A>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "ExponentOfPcElement",
[ IsModuloPcgs, IsObject, IsPosInt ] );
#############################################################################
##
#O ExponentsOfPcElement( <pcgs>, <elm>[, <posran>] )
##
## <#GAPDoc Label="ExponentsOfPcElement">
## <ManSection>
## <Oper Name="ExponentsOfPcElement" Arg='pcgs, elm[, posran]'/>
##
## <Description>
## returns the exponents of <A>elm</A> with respect to <A>pcgs</A>.
## The three argument version returns the exponents in the positions
## given in <A>posran</A>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "ExponentsOfPcElement",
[ IsModuloPcgs, IsObject ] );
#############################################################################
##
#O ExponentsOfConjugate( <pcgs>, <i>, <j> )
##
## <#GAPDoc Label="ExponentsOfConjugate">
## <ManSection>
## <Oper Name="ExponentsOfConjugate" Arg='pcgs, i, j'/>
##
## <Description>
## returns the exponents of
## <C><A>pcgs</A>[<A>i</A>]^<A>pcgs</A>[<A>j</A>]</C> with respect to
## <A>pcgs</A>. For the family pcgs or pcgs induced by it (see section
## <Ref Sect="Subgroups of Polycyclic Groups - Induced Pcgs"/>), this
## might be faster than computing the element and computing its exponent
## vector.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "ExponentsOfConjugate",
[ IsModuloPcgs, IsPosInt,IsPosInt ] );
#############################################################################
##
#O ExponentsOfRelativePower( <pcgs>, <i> )
##
## <#GAPDoc Label="ExponentsOfRelativePower">
## <ManSection>
## <Oper Name="ExponentsOfRelativePower" Arg='pcgs, i'/>
##
## <Description>
## For <M>p = <A>pcgs</A>[<A>i</A>]</M> this function returns the
## exponent vector with respect to <A>pcgs</A> of the element <M>p^e</M>
## where <M>e</M> is the relative order of <A>p</A> in <A>pcgs</A>.
## For the family pcgs or pcgs induced by it (see section
## <Ref Sect="Subgroups of Polycyclic Groups - Induced Pcgs"/>), this
## might be faster than computing the element and computing its exponent
## vector.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "ExponentsOfRelativePower",
[ IsModuloPcgs, IsPosInt ] );
#############################################################################
##
#O ExponentsOfCommutator( <pcgs>, <i>, <j> )
##
## <#GAPDoc Label="ExponentsOfCommutator">
## <ManSection>
## <Oper Name="ExponentsOfCommutator" Arg='pcgs, i, j'/>
##
## <Description>
## returns the exponents of the commutator
## <C>Comm( </C><M><A>pcgs</A>[<A>i</A>], <A>pcgs</A>[<A>j</A>]</M><C> )</C>
## with respect to <A>pcgs</A>. For the family pcgs or pcgs induced by it,
## (see section <Ref Sect="Subgroups of Polycyclic Groups - Induced Pcgs"/>),
## this might be faster than computing the element and computing its
## exponent vector.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "ExponentsOfCommutator",
[ IsModuloPcgs, IsPosInt,IsPosInt ] );
#############################################################################
##
#O LeadingExponentOfPcElement( <pcgs>, <elm> )
##
## <#GAPDoc Label="LeadingExponentOfPcElement">
## <ManSection>
## <Oper Name="LeadingExponentOfPcElement" Arg='pcgs, elm'/>
##
## <Description>
## returns the leading exponent of <A>elm</A> with respect to <A>pcgs</A>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "LeadingExponentOfPcElement",
[ IsModuloPcgs, IsObject ] );
#############################################################################
##
#O DepthAndLeadingExponentOfPcElement( <pcgs>, <elm> )
##
## <#GAPDoc Label="DepthAndLeadingExponentOfPcElement">
## <ManSection>
## <Oper Name="DepthAndLeadingExponentOfPcElement" Arg='pcgs, elm'/>
##
## <Description>
## returns a list containing the depth of <A>elm</A> and the leading
## exponent of <A>elm</A> with respect to <A>pcgs</A>. (This is sometimes
## faster than asking separately.)
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "DepthAndLeadingExponentOfPcElement",
[ IsModuloPcgs, IsObject ] );
#############################################################################
##
#O PcElementByExponents( <pcgs>, <list> )
#O PcElementByExponentsNC( <pcgs>[, <basisind>], <list> )
##
## <#GAPDoc Label="PcElementByExponents">
## <ManSection>
## <Func Name="PcElementByExponents" Arg='pcgs, list'/>
## <Oper Name="PcElementByExponentsNC" Arg='pcgs[, basisind], list'/>
##
## <Description>
## returns the element corresponding to the exponent vector <A>list</A>
## with respect to <A>pcgs</A>.
## The exponents in <A>list</A> must be in the range of permissible
## exponents for <A>pcgs</A>.
## <E>It is not guaranteed that <Ref Func="PcElementByExponents"/> will
## reduce the exponents modulo the relative orders</E>.
## (You should use the operation <Ref Func="LinearCombinationPcgs"/>
## for this purpose.)
## The <C>NC</C> version does not check that the lengths of the lists
## fit together and does not check the exponent range.
## <P/>
## The three argument version gives exponents only w.r.t. the generators
## in <A>pcgs</A> indexed by <A>basisind</A>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction("PcElementByExponents");
DeclareOperation( "PcElementByExponentsNC",
[ IsModuloPcgs, IsList ] );
#############################################################################
##
#O LinearCombinationPcgs( <pcgs>, <list>[, <one>] )
##
## <#GAPDoc Label="LinearCombinationPcgs">
## <ManSection>
## <Func Name="LinearCombinationPcgs" Arg='pcgs, list[, one]'/>
##
## <Description>
## returns the product <M>\prod_i <A>pcgs</A>[i]^{{<A>list</A>[i]}}</M>.
## In contrast to <Ref Func="PcElementByExponents"/> this permits negative
## exponents.
## <A>pcgs</A> might be a list of group elements.
## In this case, an appropriate identity element
## <A>one</A> must be given.
## <A>list</A> can be empty.
## <Example><![CDATA[
## gap> G := Group( (1,2,3,4),(1,2) );; P := Pcgs(G);;
## gap> g := PcElementByExponents(P, [0,1,1,1]);
## (1,2,3)
## gap> ExponentsOfPcElement(P, g);
## [ 0, 1, 1, 1 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction("LinearCombinationPcgs");
#############################################################################
##
#F PowerPcgsElement( <pcgs>, <i>, <exp> )
##
## <ManSection>
## <Func Name="PowerPcgsElement" Arg='pcgs, i, exp'/>
##
## <Description>
## returns the power <C><A>pcgs</A>[<A>i</A>]^<A>exp</A></C>.
## <A>exp</A> may be negative.
## The function caches the results which can be advantageous in particular
## if the pcgs is not family.
## </Description>
## </ManSection>
##
DeclareGlobalFunction("PowerPcgsElement");
#############################################################################
##
#F LeftQuotientPowerPcgsElement( <pcgs>, <i>, <exp>, <elm> )
##
## <ManSection>
## <Func Name="LeftQuotientPowerPcgsElement" Arg='pcgs, i, exp, elm'/>
##
## <Description>
## returns the left quotient of <A>elm</A> by the power
## <C><A>pcgs</A>[<A>i</A>]^<A>exp</A></C>.
## </Description>
## </ManSection>
##
DeclareGlobalFunction("LeftQuotientPowerPcgsElement");
#############################################################################
##
#O SumOfPcElement( <pcgs>, <left>, <right> )
##
## <ManSection>
## <Oper Name="SumOfPcElement" Arg='pcgs, left, right'/>
##
## <Description>
## returns the element in the span of <A>pcgs</A> whose coefficients are
## the sums of the coefficients of <A>left</A> and <A>right</A>
## with respect to <A>pcgs</A>.
## </Description>
## </ManSection>
##
DeclareOperation(
"SumOfPcElement",
[ IsModuloPcgs, IsObject, IsObject ] );
#############################################################################
##
#O ReducedPcElement( <pcgs>, <x>, <y> )
##
## <#GAPDoc Label="ReducedPcElement">
## <ManSection>
## <Oper Name="ReducedPcElement" Arg='pcgs, x, y'/>
##
## <Description>
## reduces the element <A>x</A> by dividing off (from the left) a power of
## <A>y</A> such that the leading coefficient of the result with respect to
## <A>pcgs</A> becomes zero.
## The elements <A>x</A> and <A>y</A> therefore have to have the same depth.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "ReducedPcElement", [ IsModuloPcgs, IsObject, IsObject ] );
#############################################################################
##
#O RelativeOrderOfPcElement( <pcgs>, <elm> )
##
## <#GAPDoc Label="RelativeOrderOfPcElement">
## <ManSection>
## <Oper Name="RelativeOrderOfPcElement" Arg='pcgs, elm'/>
##
## <Description>
## The relative order of <A>elm</A> with respect to the prime order pcgs
## <A>pcgs</A>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation(
"RelativeOrderOfPcElement",
[ IsModuloPcgs, IsObject ] );
#############################################################################
##
#O HeadPcElementByNumber( <pcgs>, <elm>, <dep> )
##
## <#GAPDoc Label="HeadPcElementByNumber">
## <ManSection>
## <Oper Name="HeadPcElementByNumber" Arg='pcgs, elm, dep'/>
##
## <Description>
## returns an element in the span of <A>pcgs</A> whose exponents for indices
## <M>1</M> to <A>dep</A><M>-1</M> with respect to <A>pcgs</A> are the same
## as those of <A>elm</A>, the remaining exponents are zero.
## This can be used to obtain more
## <Q>simple</Q> elements if only representatives in a factor are required.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "HeadPcElementByNumber",
[ IsModuloPcgs, IsObject, IsInt ] );
#############################################################################
##
#O CleanedTailPcElement( <pcgs>, <elm>, <dep> )
##
## <#GAPDoc Label="CleanedTailPcElement">
## <ManSection>
## <Oper Name="CleanedTailPcElement" Arg='pcgs, elm, dep'/>
##
## <Description>
## returns an element in the span of <A>pcgs</A> whose exponents for indices
## <M>1</M> to <M><A>dep</A>-1</M> with respect to <A>pcgs</A> are the same
## as those of <A>elm</A>, the remaining exponents are undefined.
## This can be used to obtain more
## <Q>simple</Q> elements if only representatives in a factor are required,
## see <Ref Sect="Factor Groups of Polycyclic Groups - Modulo Pcgs"/>.
## <P/>
## The difference to <Ref Oper="HeadPcElementByNumber"/>
## is that this function is guaranteed to zero out trailing
## coefficients while <Ref Oper="CleanedTailPcElement"/> will only do this
## if it can be done cheaply.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "CleanedTailPcElement",
[ IsModuloPcgs, IsObject, IsInt ] );
#############################################################################
##
#O ExtendedIntersectionSumPcgs( <parent-pcgs>, <n>, <u>, <modpcgs> )
##
## <ManSection>
## <Oper Name="ExtendedIntersectionSumPcgs"
## Arg='parent-pcgs, n, u, modpcgs'/>
##
## <Description>
## <E>@ The specification of this function is not clear. Do not use (or
## document this function properly before using it</E>@.
## The function returns a record whose entries are <E>not</E> pcgs but only
## lists of pc elements (to avoid unnecessary creation of InducedPcgs)
## If <A>modpcgs</A> is a tail if the <A>parent-pcgs</A>
## it is sufficient to give the starting depth,
## </Description>
## </ManSection>
##
DeclareOperation( "ExtendedIntersectionSumPcgs",
[ IsModuloPcgs, IsList, IsList, IsObject ] );
#############################################################################
##
#O IntersectionSumPcgs( <parent-pcgs>, <n>, <u> )
##
## <ManSection>
## <Oper Name="IntersectionSumPcgs" Arg='parent-pcgs, n, u'/>
##
## <Description>
## <E>@ The specification of this function is not clear. Do not use (or
## document this function properly before using it</E>@.
## </Description>
## </ManSection>
##
DeclareOperation( "IntersectionSumPcgs", [ IsModuloPcgs, IsList, IsList ] );
#############################################################################
##
#O NormalIntersectionPcgs( <parent-pcgs>, <n>, <u> )
##
## <ManSection>
## <Oper Name="NormalIntersectionPcgs" Arg='parent-pcgs, n, u'/>
##
## <Description>
## <E>@ The specification of this function is not clear. Do not use (or
## document this function properly before using it</E>@.
## </Description>
## </ManSection>
##
DeclareOperation( "NormalIntersectionPcgs", [ IsModuloPcgs, IsList, IsList ] );
#############################################################################
##
#O SumPcgs( <parent-pcgs>, <n>, <u> )
##
## <ManSection>
## <Oper Name="SumPcgs" Arg='parent-pcgs, n, u'/>
##
## <Description>
## <E>@ The specification of this function is not clear. Do not use (or
## document this function properly before using it</E>@.
## </Description>
## </ManSection>
##
DeclareOperation( "SumPcgs", [ IsModuloPcgs, IsList, IsList ] );
#############################################################################
##
#O SumFactorizationFunctionPcgs( <parentpcgs>, <n>, <u>, <kerpcgs> )
##
## <#GAPDoc Label="SumFactorizationFunctionPcgs">
## <ManSection>
## <Oper Name="SumFactorizationFunctionPcgs"
## Arg='parentpcgs, n, u, kerpcgs'/>
##
## <Description>
## computes the sum and intersection of the lists <A>n</A> and <A>u</A> whose
## elements form modulo pcgs induced by <A>parentpcgs</A> for two subgroups
## modulo a kernel given by <A>kerpcgs</A>.
## If <A>kerpcgs</A> is a tail if the <A>parent-pcgs</A> it is sufficient
## to give the starting depth,
## this can be more efficient than to construct an explicit pcgs.
## The factor group modulo <A>kerpcgs</A> generated by <A>n</A> must be
## elementary abelian and normal under <A>u</A>.
## <P/>
## The function returns a record with components
## <List>
## <Mark><C>sum</C></Mark>
## <Item>
## elements that form a modulo pcgs for the span of both subgroups.
## </Item>
## <Mark><C>intersection</C></Mark>
## <Item>
## elements that form a modulo pcgs for the intersection of
## both subgroups.
## </Item>
## <Mark><C>factorization</C></Mark>
## <Item>
## a function that returns for an element <A>x</A> in the span
## of <C>sum</C> a record with components <C>u</C> and <C>n</C>
## that give its decomposition.
## </Item>
## </List>
## <P/>
## The record components <C>sum</C> and <C>intersection</C> are <E>not</E>
## pcgs but only lists of pc elements (to avoid unnecessary creation of
## induced pcgs).
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation(
"SumFactorizationFunctionPcgs",
[ IsModuloPcgs, IsList, IsList, IsObject ] );
#############################################################################
##
#F EnumeratorByPcgs( <pcgs>, <poss> )
##
## <ManSection>
## <Func Name="EnumeratorByPcgs" Arg='pcgs, poss'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareOperation(
"EnumeratorByPcgs",
[ IsModuloPcgs ] );
#############################################################################
##
#O ExtendedPcgs( <N>, <gens> )
##
## <#GAPDoc Label="ExtendedPcgs">
## <ManSection>
## <Oper Name="ExtendedPcgs" Arg='N, gens'/>
##
## <Description>
## extends the pcgs <A>N</A> (induced w.r.t. <A>home</A>) to a new
## induced pcgs by prepending <A>gens</A>.
## No checks are performed that this really yields an induced pcgs.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "ExtendedPcgs", [ IsModuloPcgs, IsList ] );
#############################################################################
##
#F PcgsByIndependentGeneratorsOfAbelianGroup( <A> )
##
## <ManSection>
## <Func Name="PcgsByIndependentGeneratorsOfAbelianGroup" Arg='A'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareGlobalFunction( "PcgsByIndependentGeneratorsOfAbelianGroup" );
#############################################################################
##
#F Pcgs_OrbitStabilizer( <pcgs>,<domain>,<pnt>,<oprs>,<opr> )
##
## <#GAPDoc Label="Pcgs_OrbitStabilizer:pcgs">
## <ManSection>
## <Func Name="Pcgs_OrbitStabilizer" Arg='pcgs,domain,pnt,oprs,opr'/>
##
## <Description>
## runs a solvable group orbit-stabilizer algorithm on <A>pnt</A> with
## <A>pcgs</A> acting via the images <A>oprs</A> and the operation function
## <A>opr</A>.
## The domain <A>domain</A> can be used to speed up search,
## if it is not known, <K>false</K> can be given instead.
## The function
## returns a record with components <C>orbit</C>, <C>stabpcgs</C> and
## <C>lengths</C>, the
## latter indicating the lengths of the orbit whenever it got extended.
## This can be used to recompute transversal elements.
## This function should be used only inside algorithms when speed is
## essential.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "Pcgs_OrbitStabilizer" );
DeclareGlobalFunction( "Pcs_OrbitStabilizer" );
DeclareGlobalFunction( "Pcgs_OrbitStabilizer_Blist" );
## <#GAPDoc Label="[1]{pcgs}">
## The following functions are intended for working with factor groups
## obtained by factoring out the tail of a pcgs.
## They provide a way to map elements or induced pcgs quickly in the factor
## (respectively to take preimages) without the need to construct a
## homomorphism.
## <P/>
## The setup is always a pcgs <A>pcgs</A> of <A>G</A> and a pcgs
## <A>fpcgs</A> of a factor group <M>H = <A>G</A>/<A>N</A></M>
## which corresponds to a head of <A>pcgs</A>.
## <P/>
## No tests for validity of the input are performed.
## <#/GAPDoc>
##
#############################################################################
##
#F LiftedPcElement( <pcgs>, <fpcgs>, <elm> )
##
## <#GAPDoc Label="LiftedPcElement">
## <ManSection>
## <Func Name="LiftedPcElement" Arg='pcgs, fpcgs, elm'/>
##
## <Description>
## returns a preimage in <A>G</A> of an element <A>elm</A> of <A>H</A>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "LiftedPcElement" );
#############################################################################
##
#F ProjectedPcElement( <pcgs>, <fpcgs>, <elm> )
##
## <#GAPDoc Label="ProjectedPcElement">
## <ManSection>
## <Func Name="ProjectedPcElement" Arg='pcgs, fpcgs, elm'/>
##
## <Description>
## returns the image in <A>H</A> of an element <A>elm</A> of <A>G</A>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "ProjectedPcElement" );
#############################################################################
##
#F ProjectedInducedPcgs( <pcgs>, <fpcgs>, <ipcgs> )
##
## <#GAPDoc Label="ProjectedInducedPcgs">
## <ManSection>
## <Func Name="ProjectedInducedPcgs" Arg='pcgs, fpcgs, ipcgs'/>
##
## <Description>
## <A>ipcgs</A> must be an induced pcgs with respect to <A>pcgs</A>.
## This operation returns an induced pcgs with respect to <A>fpcgs</A>
## consisting of the nontrivial images of <A>ipcgs</A>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "ProjectedInducedPcgs" );
#############################################################################
##
#F LiftedInducedPcgs( <pcgs>, <fpcgs>, <ipcgs>, <ker> )
##
## <#GAPDoc Label="LiftedInducedPcgs">
## <ManSection>
## <Func Name="LiftedInducedPcgs" Arg='pcgs, fpcgs, ipcgs, ker'/>
##
## <Description>
## <A>ipcgs</A> must be an induced pcgs with respect to <A>fpcgs</A>.
## This operation returns an induced pcgs with respect to <A>pcgs</A>
## consisting of the preimages of <A>ipcgs</A>,
## appended by the elements in <A>ker</A> (assuming
## there is a bijection of <A>pcgs</A> mod <A>ker</A> to <A>fpcgs</A>).
## <A>ker</A> might be a simple element list.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "LiftedInducedPcgs" );
#############################################################################
##
#F PcgsByPcgs( <pcgs>, <decomp>, <family>, <images> )
##
## <#GAPDoc Label="PcgsByPcgs">
## <ManSection>
## <Func Name="PcgsByPcgs" Arg='pcgs, decomp, family, images'/>
##
## <Description>
## Constructs a pcgs that will use another pcgs (via an isomorphism pc
## group) to determine exponents. The assumption is that exponents will be
## so expensive that a pc group collection is of neglegible cost.
## <A>pcgs</A> is the list of pc elements
## desired. <A>decomp</A> is another pcgs with respect to which we can
## compute exponents. It corresponds to the family pcgs <A>family</A> of an
## isomorphic pc group. In this pc group <A>images</A> are the images of
## <A>pcgs</A>. Exponents will be computed by forming exponents with
## respect to <A>decomp</A>, forming the image in the pc group, and then
## computing exponents of this image by <A>images</A>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "PcgsByPcgs" );
[ Dauer der Verarbeitung: 0.11 Sekunden
(vorverarbeitet)
]
|
