|
#############################################################################
##
## 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 methods for the construction of the basic perm
## group types.
##
#############################################################################
##
#M TrivialGroupCons( <IsPermGroup> )
##
InstallMethod( TrivialGroupCons,
"perm group",
[ IsPermGroup and IsTrivial ],
function( filter )
return GroupByGenerators( [], () );
end );
#############################################################################
##
#M AbelianGroupCons( <IsPermGroup>, <ints> )
##
InstallMethod( AbelianGroupCons,
"perm group",
true,
[ IsPermGroup and IsAbelian,
IsList ],
0,
function( filter, ints )
local grp, grps;
if IsEmpty( ints ) then
# Create a group with empty list of generators
return GroupWithGenerators( [], () );
fi;
if not ForAll( ints, IsInt ) then
Error( "<ints> must be a list of integers" );
fi;
if not ForAll( ints, x -> 0 < x ) then
TryNextMethod();
fi;
grps := List( ints, x -> CyclicGroupCons( IsPermGroup, x ) );
# the way a direct product is constructed guarantees the right
# generators (also generators of order 1)
grp := CallFuncList( DirectProduct, grps );
SetSize( grp, Product(ints) );
SetIsAbelian( grp, true );
return grp;
end );
#############################################################################
##
#M ElementaryAbelianGroupCons( <IsPermGroup>, <size> )
##
InstallMethod( ElementaryAbelianGroupCons, "perm group", true,
[ IsPermGroup and IsElementaryAbelian, IsPosInt ],
0,function(filter,size)
local G;
if size = 1 or IsPrimePowerInt( size ) then
G := AbelianGroup( filter, Factors(size) );
else
Error( "<n> must be a prime power" );
fi;
SetIsElementaryAbelian( G, true );
return G;
end);
#############################################################################
##
#M AlternatingGroupCons( <IsPermGroup>, <deg> )
##
InstallMethod( AlternatingGroupCons,
"perm group with degree",
true,
[ IsPermGroup and IsFinite,
IsInt],
0,
function( filter, deg )
if deg<0 then TryNextMethod();fi;
return AlternatingGroupCons( IsPermGroup, [ 1 .. deg ] );
end );
#############################################################################
##
#M AlternatingGroupCons( <IsPermGroup>, <dom> )
##
InstallOtherMethod( AlternatingGroupCons,
"perm group with domain",
true,
[ IsPermGroup and IsFinite,
IsDenseList ],
0,
function( filter, dom )
local alt, dl, g, l;
dom := Set(dom);
IsRange( dom );
if Length(dom) < 3 then
alt := GroupByGenerators( [], () );
SetSize( alt, 1 );
SetMovedPoints( alt, [] );
SetNrMovedPoints( alt, 0 );
SetIsPerfectGroup( alt, true );
else
if Length(dom) mod 2 = 0 then
dl := dom{[ 1 .. Length(dom)-1 ]};
else
dl := dom;
fi;
g := [ MappingPermListList( dl, Concatenation( dl{[2..Length(dl)]},
[dl[1]] ) ) ];
if 3 < Length(dom) then
l := Length(dom);
Add( g, (dom[l-2],dom[l-1],dom[l]) );
fi;
alt := GroupByGenerators(g);
if Length(dom)<5000 then
SetSize( alt, Factorial(Length(dom))/2 );
fi;
SetMovedPoints( alt, dom );
SetNrMovedPoints( alt, Length(dom) );
if 4 < Length(dom) then
SetIsNonabelianSimpleGroup( alt, true );
elif 2 < Length(dom) then
SetIsPerfectGroup( alt, false );
fi;
SetIsPrimitiveAffine( alt, Length( dom ) < 5 );
fi;
SetIsAlternatingGroup( alt, true );
SetIsNaturalAlternatingGroup( alt, true );
return alt;
end );
#############################################################################
##
#M AlternatingGroupCons( <IsPermGroup and IsRegular>, <deg> )
##
InstallMethod( AlternatingGroupCons,
"regular perm group with degree",
true,
[ IsPermGroup and IsRegular and IsFinite,
IsInt],
0,
function( filter, deg )
if deg<0 then TryNextMethod();fi;
return AlternatingGroupCons( IsPermGroup and IsRegular,
[ 1 .. deg ] );
end );
#############################################################################
##
#M AlternatingGroupCons( <IsPermGroup and IsRegular>, <dom> )
##
InstallOtherMethod( AlternatingGroupCons,
"regular perm group with domain",
true,
[ IsPermGroup and IsRegular and IsFinite,
IsDenseList ],
0,
function( filter, dom )
local alt;
alt := AlternatingGroupCons( IsPermGroup, dom );
alt := Action( alt, AsList(alt), OnRight );
SetIsAlternatingGroup( alt, true );
return alt;
end );
#############################################################################
##
#M CyclicGroupCons( <IsPermGroup and IsRegular>, <n> )
##
InstallMethod( CyclicGroupCons,
"regular perm group",
true,
[ IsPermGroup and IsRegular and IsCyclic,
IsInt and IsPosRat ],
0,
function( filter, n )
local g, c;
g := PermList( Concatenation( [2..n], [1] ) );
c := GroupByGenerators( [g] );
SetSize( c, n );
SetIsCyclic( c, true );
if n > 1 then
SetMinimalGeneratingSet (c, [g]);
else
SetMinimalGeneratingSet (c, []);
fi;
return c;
end );
#############################################################################
##
#M DihedralGroupCons( <IsPermGroup>, <2n> )
##
InstallMethod( DihedralGroupCons,
"perm. group",
true,
[ IsPermGroup, IsPosInt ], 0,
function( filter, 2n )
local D, g, h;
if 2n = 2 then
D:= GroupByGenerators( [ (1,2) ] );
elif 2n = 4 then
D := GroupByGenerators( [ (1,2), (3,4) ] );
elif 2n mod 2 = 1 then
TryNextMethod();
else
g:= PermList( Concatenation( [ 2 .. 2n/2 ], [ 1 ] ) );
h:= PermList( Concatenation( [ 1 ], Reversed( [ 2 .. 2n/2 ] ) ) );
D:= GroupByGenerators( [ g, h ] );
fi;
return D;
end );
#############################################################################
##
#M DicyclicGroupCons( <IsPermGroup>, <4n> )
##
InstallMethod( DicyclicGroupCons,
"perm. group",
true,
[ IsPermGroup, IsPosInt ], 0,
function( filter, n )
local y, z, x;
if 0 <> n mod 4 then TryNextMethod(); fi;
y := PermList( Concatenation( [2..n/2], [1], [n/2+2..n], [n/2+1] ) );
x := PermList( Concatenation( Cycle( y^-1, [n/2+1..n], n/2+1 ), Cycle( y^-1, [1..n/2], n/4+1 ) ) );
return Group(x,y);
end );
#############################################################################
##
#M MathieuGroupCons( <IsPermGroup>, <degree> )
##
## The returned permutation groups are compatible only in the following way.
## $M_{23}$ is the stabilizer of the point $24$ in $M_{24}$.
## $M_{21}$ is the stabilizer of the point $22$ in $M_{22}$.
## $M_{11}$ is the stabilizer of the point $12$ in $M_{12}$.
## $M_{10}$ is the stabilizer of the point $11$ in $M_{11}$.
## $M_{9}$ is the stabilizer of the point $10$ in $M_{10}$.
##
InstallMethod( MathieuGroupCons,
"perm group with degree",
[ IsPermGroup and IsFinite, IsPosInt ],
function( filter, degree )
local M;
# degree 9, base 1 2, indices 9 8
if degree = 9 then
M:= Group(
(1,4,9,8)(2,5,3,6),
(1,6,5,2)(3,7,9,8) );
SetSize( M, 72 );
# degree 10, base 1 2 3, indices 10 9 8
elif degree = 10 then
M:= Group(
(1,9,6,7,5)(2,10,3,8,4),
(1,10,7,8)(2,9,4,6) );
SetSize( M, 720 );
# degree 11, base 1 2 3 4, indices 11 10 9 8
elif degree = 11 then
M:= Group(
(1,2,3,4,5,6,7,8,9,10,11),
(3,7,11,8)(4,10,5,6) );
SetSize( M, 7920 );
SetIsNonabelianSimpleGroup( M, true );
# degree 12, base 1 2 3 4 5, indices 12 11 10 9 8
elif degree = 12 then
M:= Group(
(1,2,3,4,5,6,7,8,9,10,11),
(3,7,11,8)(4,10,5,6),
(1,12)(2,11)(3,6)(4,8)(5,9)(7,10) );
SetSize( M, 95040 );
SetIsNonabelianSimpleGroup( M, true );
# degree 21, base 1 2 3 4, indices 21 20 16 3
elif degree = 21 then
M:= Group(
(1,4,5,9,3)(2,8,10,7,6)(12,15,16,20,14)(13,19,21,18,17),
(1,21,5,12,20)(2,16,3,4,17)(6,18,7,19,15)(8,13,9,14,11) );
SetSize( M, 20160 );
SetIsNonabelianSimpleGroup( M, true );
# degree 22, base 1 2 3 4 5, indices 22 21 20 16 3
elif degree = 22 then
M:= Group(
(1,2,3,4,5,6,7,8,9,10,11)(12,13,14,15,16,17,18,19,20,21,22),
(1,4,5,9,3)(2,8,10,7,6)(12,15,16,20,14)(13,19,21,18,17),
(1,21)(2,10,8,6)(3,13,4,17)(5,19,9,18)(11,22)(12,14,16,20) );
SetSize( M, 443520 );
SetIsNonabelianSimpleGroup( M, true );
# degree 23, base 1 2 3 4 5 6, indices 23 22 21 20 16 3
elif degree = 23 then
M:= Group(
(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23),
(3,17,10,7,9)(4,13,14,19,5)(8,18,11,12,23)(15,20,22,21,16) );
SetSize( M, 10200960 );
SetIsNonabelianSimpleGroup( M, true );
# degree 24, base 1 2 3 4 5 6 7, indices 24 23 22 21 20 16 3
elif degree = 24 then
M:= Group(
(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23),
(3,17,10,7,9)(4,13,14,19,5)(8,18,11,12,23)(15,20,22,21,16),
(1,24)(2,23)(3,12)(4,16)(5,18)(6,10)(7,20)(8,14)(9,21)(11,17)
(13,22)(19,15) );
SetSize( M, 244823040 );
SetIsNonabelianSimpleGroup( M, true );
# error
else
Error("degree <d> must be 9, 10, 11, 12, 21, 22, 23, or 24" );
fi;
return M;
end );
#############################################################################
##
#M SymmetricGroupCons( <IsPermGroup>, <deg> )
##
InstallMethod( SymmetricGroupCons,
"perm group with degree",
true,
[ IsPermGroup and IsFinite,
IsInt ],
0,
function( filter, deg )
if deg<0 then TryNextMethod();fi;
return SymmetricGroupCons( IsPermGroup, [ 1 .. deg ] );
end );
#############################################################################
##
#M SymmetricGroupCons( <IsPermGroup>, <dom> )
##
InstallOtherMethod( SymmetricGroupCons,
"perm group with domain",
true,
[ IsPermGroup and IsFinite,
IsDenseList ],
0,
function( filters, dom )
local sym, g;
dom := Set(dom);
IsRange( dom );
if Length(dom) < 2 then
sym := GroupByGenerators( [], () );
SetSize( sym, 1 );
SetMovedPoints( sym, [] );
SetNrMovedPoints( sym, 0 );
SetIsPerfectGroup( sym, true );
else
g := [ MappingPermListList( dom, Concatenation(
dom{[2..Length(dom)]}, [ dom[1] ] ) ) ];
if 2 < Length(dom) then
Add( g, ( dom[1], dom[2] ) );
fi;
sym := GroupByGenerators( g );
if Length(dom)<5000 then
SetSize( sym, Factorial(Length(dom)) );
fi;
SetMovedPoints( sym, dom );
SetNrMovedPoints( sym, Length(dom) );
SetIsPerfectGroup( sym, false );
fi;
SetIsPrimitiveAffine( sym, Length( dom ) < 5 );
SetIsSymmetricGroup( sym, true );
SetIsNaturalSymmetricGroup( sym, true );
return sym;
end );
#############################################################################
##
#M SymmetricGroupCons( <IsPermGroup and IsRegular>, <deg> )
##
InstallMethod( SymmetricGroupCons,
"regular perm group with degree",
true,
[ IsPermGroup and IsRegular and IsFinite,
IsInt],
0,
function( filter, deg )
if deg<0 then TryNextMethod();fi;
return SymmetricGroupCons( IsPermGroup and IsRegular,
[ 1 .. deg ] );
end );
#############################################################################
##
#M SymmetricGroupCons( <IsPermGroup and IsRegular>, <dom> )
##
InstallOtherMethod( SymmetricGroupCons,
"regular perm group with domain",
true,
[ IsPermGroup and IsRegular and IsFinite,
IsDenseList ],
0,
function( filter, dom )
local alt;
alt := SymmetricGroupCons( IsPermGroup, dom );
alt := Action( alt, AsList(alt), OnRight );
SetIsSymmetricGroup( alt, true );
return alt;
end );
[ Verzeichnis aufwärts0.22unsichere Verbindung
Übersetzung europäischer Sprachen durch Browser
]
|
