|
#############################################################################
##
#W gp4obj.gi GAP4 package `XMod' Chris Wensley
## Alper Odabas
## This file implements generic methods for (pre-)crossed cubes
## and (pre-)cat3-groups.
##
#Y Copyright (C) 2001-2025, Chris Wensley et al,
#############################################################################
##
#M PreCat3GroupObj( [<front>,<left>,<up>,<right>,<down>,<back>] )
##
InstallMethod( PreCat3GroupObj, "for a list of pre-cat2-groups", true,
[ IsList ], 0,
function( L )
local PC, ok;
if not ( Length( L ) = 6 ) then
Error( "there should be 6 pre-cat2-groups in the list L" );
fi;
PC := rec();
ObjectifyWithAttributes( PC, PreCat3GroupObjType,
Front3DimensionalGroup, L[1],
Left3DimensionalGroup, L[2],
Up3DimensionalGroup, L[3],
Right3DimensionalGroup, L[4],
Down3DimensionalGroup, L[5],
Back3DimensionalGroup, L[6],
GeneratingCat1Groups, [ Up2DimensionalGroup( L[1] ),
Left2DimensionalGroup( L[1] ),
Left2DimensionalGroup( L[2] ) ],
HigherDimension, 4,
IsHigherDimensionalGroup, true,
IsPreCat3Group, true,
IsPreCatnGroup, true );
ok := IsCat3Group( PC );
return PC;
end );
#############################################################################
##
#M IsPreCat3Group . . . . . . . . . . . check that this is a pre-cat3-group
#M IsCat3Group . . . . . . . . . . . . check that the object is a cat3-group
##
InstallMethod( IsCat3Group, "generic method for a cat3-group",
true, [ IsHigherDimensionalGroup ], 0,
function( P )
return ( HigherDimension( P ) = 4 )
and IsCat2Group( Front3DimensionalGroup( P ) )
and IsCat2Group( Left3DimensionalGroup( P ) )
and IsCat2Group( Up3DimensionalGroup( P ) )
and IsCat2Group( Right3DimensionalGroup( P ) )
and IsCat2Group( Down3DimensionalGroup( P ) )
and IsCat2Group( Back3DimensionalGroup( P ) );
end );
#############################################################################
##
#M DetermineRemainingFaces . . . . . . . . . . . for list of pre-catn-groups
##
InstallGlobalFunction( DetermineRemainingFaces, function( arg )
local nargs, C1;
nargs := Length( arg );
if ( nargs = 2 ) then
if IsPreCat1Group(arg[1]) and IsPreCat1Group(arg[2]) then
return DetermineRemainingCat1Groups( arg[1], arg[2] );
elif IsPreCat2Group(arg[1]) and IsPreCat2Group(arg[2]) then
return DetermineRemainingCat2Groups( arg[1], arg[2] );
else
return fail;
fi;
else
return fail;
fi;
end );
#############################################################################
##
#M DetermineRemainingCat2Groups . . . . . . . . . . for two pre-cat2-groups
##
InstallMethod( DetermineRemainingCat2Groups, "for front,left pre-cat2-gps",
true, [ IsPreCat2Group, IsPreCat2Group ], 0,
function( front, left )
local Cfl, Cfu, Cll, up, Cud, Cfr, right, Cfd, Clr, down,
Cld, Cur, back, Crd, G, R, Q, H, N, P, M, L;
Cfl := Left2DimensionalGroup( front );
if not ( Cfl = Up2DimensionalGroup( left ) ) then
Error( "front-left mis-match" );
fi;
Cfu := Up2DimensionalGroup( front );
Cll := Left2DimensionalGroup( left );
up := Cat2Group( Cll, Cfu );
if ( up = fail ) then
Info( InfoXMod, 1, "up fails to be a cat2-group" );
return fail;
fi;
Cud := Down2DimensionalGroup( up );
Cfr := Right2DimensionalGroup( front );
right := Cat2Group( Cud, Cfr );
if ( right = fail ) then
Info( InfoXMod, 1, "right fails to be a cat2-group" );
return fail;
fi;
Cfd := Down2DimensionalGroup( front );
Clr := Right2DimensionalGroup( left );
down := Cat2Group( Cfd, Clr );
if ( down = fail ) then
Info( InfoXMod, 1, "down fails to be a cat2-group" );
return fail;
fi;
Cld := Down2DimensionalGroup( left );
Cur := Right2DimensionalGroup( up );
back := Cat2Group( Cld, Cur );
if ( back = fail ) then
Info( InfoXMod, 1, "back fails to be a cat2-group" );
return fail;
fi;
return [ up, right, down, back ];
end );
#############################################################################
##
#M PreCat3GroupByPreCat2Groups( <front>,<left>,<up>,<right>,<down>,<back> )
##
InstallMethod( PreCat3GroupByPreCat2Groups, "for a pair of pre-cat2-groups",
true, [ IsPreCat2Group, IsPreCat2Group, IsPreCat2Group,
IsPreCat2Group, IsPreCat2Group, IsPreCat2Group ], 0,
function( front, left, up, right, down, back )
local Cfu, Cfl, Cul, Cur, Cfr, Cfd, Cld, Clb, Cub, Crd,
G, R, Q, H, N, P, M, L;
Cfu := Up2DimensionalGroup( front );
Cfl := Left2DimensionalGroup( front );
Cul := Up2DimensionalGroup( up );
Cur := Down2DimensionalGroup( up );
Cfr := Right2DimensionalGroup( front );
Cfd := Down2DimensionalGroup( front );
Cld := Down2DimensionalGroup( left );
Clb := Down2DimensionalGroup( left );
Cub := Right2DimensionalGroup( up );
Crd := Down2DimensionalGroup( right );
G := Source( Cfu );
R := Range( Cfu );
Q := Range( Cfl );
H := Range( Cub );
N := Range( Cur );
P := Range( Cfd );
M := Range( Cld );
L := Range( Crd );
return PreCat3GroupObj( [ front, left, up, right, down, back ] );
end );
#############################################################################
##
#F (Pre)Cat3Group( front, left ) cat3-group from two (pre)cat2-groups
#F (Pre)Cat3Group( front, uplt ) cat3-group from cat2 and cat1-groups
#F (Pre)Cat3Group( fup, flt, llt ) cat3-group from 3 cat1-groups
#F (Pre)Cat3Group( XS ) cat3-group from (pre)crossed cube
##
InstallGlobalFunction( PreCat3Group, function( arg )
local nargs, front, left, Cfl, Clu, urdb, C3G, ok;
nargs := Length( arg );
if ( ( nargs < 1 ) or ( nargs > 3 ) ) then
Print( "standard usage: (Pre)Cat3Group( front, left );\n" );
Print( " or: (Pre)Cat3Group( front, cat1 );\n" );
Print( " or: (Pre)Cat3Group( cat1, cat1, cat1 );\n" );
Print( " or: (Pre)Cat3Group( Xcube );\n" );
return fail;
fi;
if not ForAll( arg, HasHigherDimension ) then
Error( "each argument should have a higher dimension" );
fi;
if ( nargs = 1 ) then
Error( "PreCat3GroupOfPreCrossedcube not yet implemented" );
## C3G := PreCat3GroupOfPreCrossedcube( arg[1] );
elif ( nargs = 3 ) then
front := PreCat2Group( arg[1], arg[2] );
left := PreCat2Group( arg[2], arg[3] );
elif ( nargs = 2 ) and ( HigherDimension( arg[2] ) = 2 ) then
front := arg[1];
Cfl := Left2DimensionalGroup( arg[1] );
left := PreCat2Group( Cfl, arg[2] );
else
front := arg[1];
left := arg[2];
fi;
if ( ( front = fail ) or (left = fail ) ) then
return fail;
fi;
if not IsPreCat2Group( front ) and IsPreCat2Group( left ) then
Error( "front and left are not both pre-cat2-groups" );
fi;
Cfl := Left2DimensionalGroup( front );
Clu := Up2DimensionalGroup( left );
if not ( Cfl = Clu ) then
Info( InfoXMod, 1, "front-left <> left-up" );
return fail;
fi;
urdb := DetermineRemainingCat2Groups( front, left );
if ( urdb = fail ) then
Info( InfoXMod, 2, "failure with RemainingCat2Groups" );
return fail;
fi;
C3G := PreCat3GroupByPreCat2Groups(
front, left, urdb[1], urdb[2], urdb[3], urdb[4] );
if ( C3G = fail ) then
return fail;
fi;
ok := IsPreCat3Group( C3G );
if ok then
ok := IsCat3Group( C3G );
return C3G;
else
return fail;
fi;
end );
InstallGlobalFunction( Cat3Group, function( arg )
local nargs, C3G, ok;
nargs := Length( arg );
if ( nargs = 3 ) then
C3G := PreCat3Group( arg[1], arg[2], arg[3] );
elif ( nargs = 2 ) then
C3G := PreCat3Group( arg[1], arg[2] );
elif ( nargs = 1 ) then
C3G := PreCat3Group( arg[1] );
else
Print( "standard usage: (Pre)Cat3Group( cat2, cat2 );\n" );
Print( " or: (Pre)Cat3Group( cat2, cat1 );\n" );
Print( " or: (Pre)Cat3Group( cat1, cat1, cat1 );\n" );
Print( " or: (Pre)Cat3Group( XCube );\n" );
return fail;
fi;
ok := not ( C3G = fail ) and IsCat3Group( C3G );
if ok then
return C3G;
else
return fail;
fi;
end );
InstallMethod( AllCat3GroupTriples, "for a group", [ IsGroup ], 0,
function( G )
local all1, all2, pairs, T, t, n, i, j, k, front, left, up, a, b, c, pos;
InitCatnGroupRecords( G );
if IsBound( CatnGroupLists( G ).cat3triples ) then
return CatnGroupLists( G ).cat3triples;
fi;
all1 := AllCat1Groups( G );
all2 := AllCat2Groups( G );
pairs := CatnGroupLists( G ).cat2pairs;
T := [ ];
t := 0;
n := Length( pairs );
for i in [1..n] do
front := pairs[i];
a := front[1];
b := front[2];
for j in [i..n] do
left := pairs[j];
if ( left[1] = b ) then
c := left[2];
up := [ c, a ];
pos := Position( pairs, up );
if ( pos = fail ) then
pos := Position( pairs, [ a, c ] );
fi;
if ( pos <> fail ) then
Add( T, [ a, b, c ] );
t := t+1;
fi;
fi;
od;
od;
CatnGroupNumbers( G ).cat3 := Length( T );
CatnGroupLists( G ).cat3triples := T;
return T;
end );
InstallMethod( AllCat3GroupsNumber, "for a group", [ IsGroup ], 0,
function( G )
local n, C, triples;
InitCatnGroupRecords( G );
if IsBound( CatnGroupNumbers( G ).cat3 ) then
return CatnGroupNumbers( G ).cat3;
fi;
## not already known, so perform the calculation
triples := AllCat3GroupTriples( G );
return Length( triples );
end );
InstallMethod( AllCat3Groups, "for a group", [ IsGroup ], 0,
function( G )
local all1, triples, n, L, i, t, C;
InitCatnGroupRecords( G );
all1 := AllCat1Groups( G );
triples := AllCat3GroupTriples( G );
n := Length( triples );
L := [ ];
for i in [1..n] do
t := triples[i];
C := Cat3Group( all1[t[1]], all1[t[2]], all1[t[3]] );
Add( L, C );
od;
return L;
end );
[ Dauer der Verarbeitung: 0.23 Sekunden
(vorverarbeitet)
]
|
