|
#############################################################################
##
#W construct.gi Polycyclic Max Horn
##
#############################################################################
##
#M TrivialGroupCons( <IsPcpGroup> )
##
InstallMethod( TrivialGroupCons,
"pcp group",
[ IsPcpGroup and IsFinite ],
function( filter )
return PcpGroupByCollectorNC( FromTheLeftCollector( 0 ) );
end );
#############################################################################
##
#M AbelianGroupCons( <IsPcpGroup>, <ints> )
##
InstallMethod( AbelianGroupCons,
"pcp group",
[ IsPcpGroup, IsList ],
function( filter, ints )
local coll, i, n, r, grp, gens, pos;
if not ForAll( ints, x -> IsInt(x) or IsInfinity(x) ) then
Error( "<ints> must be a list of integers" );
fi;
# We allow 0, and interpret it as indicating an infinite factor.
if not ForAll( ints, x -> 0 <= x ) then
TryNextMethod();
fi;
r := Filtered( ints, x -> x <> 1 );
n := Length(r);
# construct group
coll := FromTheLeftCollector( n );
for i in [1..n] do
if IsBound( r[i] ) and r[i] > 0 and r[i] <> infinity then
SetRelativeOrder( coll, i, r[i] );
fi;
od;
UpdatePolycyclicCollector(coll);
grp := PcpGroupByCollectorNC( coll );
if 1 in ints then
gens:= [];
pos:= 1;
for i in [ 1 .. Length( ints ) ] do
if ints[i] = 1 then
gens[i]:= One( grp );
else
gens[i]:= GeneratorsOfGroup( grp )[ pos ];
pos:= pos + 1;
fi;
od;
grp:= GroupWithGenerators( gens );
fi;
SetIsAbelian( grp, true );
return grp;
end );
#############################################################################
##
#M ElementaryAbelianGroupCons( <IsPcpGroup>, <size> )
##
InstallMethod( ElementaryAbelianGroupCons,
"pcp group",
[ IsPcpGroup and IsFinite, IsPosInt ],
function(filter,size)
local grp;
if size = 1 or IsPrimePowerInt( size ) then
grp := AbelianGroup( filter, Factors(size) );
else
Error( "<n> must be a prime power" );
fi;
SetIsElementaryAbelian( grp, true );
return grp;
end);
#############################################################################
##
#M FreeAbelianGroupCons( <IsPcpGroup>, <rank> )
##
if IsBound(FreeAbelianGroupCons) then
InstallMethod( FreeAbelianGroupCons,
"pcp group",
[ IsPcpGroup, IsInt and IsPosRat ],
function( filter, rank )
local coll, grp;
# construct group
coll := FromTheLeftCollector( rank );
UpdatePolycyclicCollector( coll );
grp := PcpGroupByCollectorNC( coll );
SetIsFreeAbelian( grp, true );
return grp;
end );
fi;
#############################################################################
##
#M CyclicGroupCons( <IsPcpGroup>, <n> )
##
InstallMethod( CyclicGroupCons,
"pcp group",
[ IsPcpGroup and IsFinite, IsPosInt ],
function( filter, n )
local coll, grp;
# construct group
coll := FromTheLeftCollector( 1 );
SetRelativeOrder( coll, 1, n );
UpdatePolycyclicCollector(coll);
grp := PcpGroupByCollectorNC( coll );
if n > 1 then
SetMinimalGeneratingSet(grp, [grp.1]);
else
SetMinimalGeneratingSet(grp, []);
fi;
return grp;
end );
#############################################################################
##
#M CyclicGroupCons( <IsPcpGroup>, infinity )
##
InstallOtherMethod( CyclicGroupCons,
"pcp group",
[ IsPcpGroup, IsInfinity ],
function( filter, n )
local coll, grp;
# construct group
coll := FromTheLeftCollector( 1 );
UpdatePolycyclicCollector(coll);
grp := PcpGroupByCollectorNC( coll );
SetMinimalGeneratingSet(grp, [grp.1]);
return grp;
end );
#############################################################################
##
#M DihedralGroupCons( <IsPcpGroup>, <n> )
##
InstallMethod( DihedralGroupCons,
"pcp group",
[ IsPcpGroup and IsFinite, IsPosInt ],
function( filter, n )
local coll, grp;
if n mod 2 = 1 then
TryNextMethod();
elif n = 2 then
return CyclicGroup( filter, 2 );
fi;
coll := FromTheLeftCollector( 2 );
SetRelativeOrder( coll, 1, 2 );
SetRelativeOrder( coll, 2, n/2 );
SetConjugate( coll, 2, 1, [2,n/2-1] );
UpdatePolycyclicCollector(coll);
grp := PcpGroupByCollectorNC( coll );
return grp;
end );
#############################################################################
##
#M DihedralGroupCons( <IsPcpGroup>, infinity )
##
InstallOtherMethod( DihedralGroupCons,
"pcp group",
[ IsPcpGroup, IsInfinity ],
function( filter, n )
local coll, grp;
coll := FromTheLeftCollector( 2 );
SetRelativeOrder( coll, 1, 2 );
SetConjugate( coll, 2, 1, [2,-1] );
SetConjugate( coll, 2, -1, [2,-1] );
UpdatePolycyclicCollector(coll);
grp := PcpGroupByCollectorNC( coll );
return grp;
end );
#############################################################################
##
#M QuaternionGroupCons( <IsPcpGroup>, <n> )
##
InstallMethod( QuaternionGroupCons,
"pcp group",
[ IsPcpGroup and IsFinite, IsPosInt ],
function( filter, n )
local coll, grp;
if 0 <> n mod 4 then
TryNextMethod();
elif n = 4 then return
CyclicGroup( filter, 4 );
fi;
coll := FromTheLeftCollector( 2 );
SetRelativeOrder( coll, 1, 2 );
SetRelativeOrder( coll, 2, n/2 );
SetPower( coll, 1, [2, n/4] );
SetConjugate( coll, 2, 1, [2,n/2-1] );
UpdatePolycyclicCollector(coll);
grp := PcpGroupByCollectorNC( coll );
return grp;
end );
#############################################################################
##
#M ExtraspecialGroupCons( <IsPcpGroup>, <order>, <exponent> )
##
InstallMethod( ExtraspecialGroupCons,
"pcp group",
[ IsPcpGroup and IsFinite,
IsInt,
IsObject ],
function( filters, order, exp )
local G;
G := ExtraspecialGroupCons( IsPcGroup and IsFinite, order, exp );
return PcGroupToPcpGroup( G );
end );
#############################################################################
##
#M AlternatingGroupCons( <IsPcpGroup>, <deg> )
##
InstallMethod( AlternatingGroupCons,
"pcp group with degree",
[ IsPcpGroup and IsFinite,
IsPosInt ],
function( filter, deg )
local alt;
if 4 < deg then
Error( "<deg> must be at most 4" );
fi;
alt := AlternatingGroupCons(IsPcGroup and IsFinite,deg);
alt := PcGroupToPcpGroup(alt);
SetIsAlternatingGroup( alt, true );
return alt;
end );
#############################################################################
##
#M SymmetricGroupCons( <IsPcpGroup>, <deg> )
##
InstallMethod( SymmetricGroupCons,
"pcp group with degree",
[ IsPcpGroup and IsFinite,
IsPosInt ],
function( filter, deg )
local sym;
if 4 < deg then
Error( "<deg> must be at most 4" );
fi;
sym := SymmetricGroupCons(IsPcGroup and IsFinite,deg);
sym := PcGroupToPcpGroup(sym);
SetIsSymmetricGroup( sym, true );
return sym;
end );
[ Dauer der Verarbeitung: 0.26 Sekunden
(vorverarbeitet)
]
|
