Quelle  gp4obj.gi   Sprache: Shell

 #############################################################################
##
#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 );