#############################################################################
##
#W  frattfree.gi                GrpConst                         Bettina Eick
#W                                                         Hans Ulrich Besche
##

#############################################################################
##
#F CheckFlags( flags )
##
## Possible flags:
##   nilpotent = true             - nilpotent groups
##   nonnilpot = true             - non-nilpotent groups
##   supersol  = true             - supersoluble groups
##   nonsupsol = true             - non-supersoluble groups
##   pnormal   = list of primes   - groups with normal Sylowgroup
##   nonpnorm  = list of primes   - groups without normal Sylowgroup
##
## If a flag is bound, then the algorithm constructs the groups with 
## this property only. Otherwise the flag should be unbound.
## Note: only the positive flags yield an improved efficiency of the method.
##
## This function checks the consistency of the given flags.
##
InstallGlobalFunction( CheckFlags, function( flags )

    # first a consistency check
    if
    (IsBound( flags.nilpotent ) and flags.nilpotent <> true ) or
    (IsBound( flags.nonnilpot ) and flags.nonnilpot <> true ) or
    (IsBound( flags.supersol ) and flags.supersol <> true ) or
    (IsBound( flags.nonsupsol ) and (IsBound( flags.nonsupsol ) and flagsnonsupsol <> true )or
    (IsBound( flags.pnormal ) and not IsList( flags.pnormal ) ) or
    (IsBound( flags.nonpnorm ) and not IsList( flags[ 1,2, 3, 4 ,6, , ,9 ,11 15,18,,23 26 ,33,36,38 39, 
    then
        Error("not a possible flags record");
    fi;

    # nilpotent
    if IsBound( flags.nilpotent ) then
        flags.supersol := true;
        if IsBound( flags.nonnilpot ) then return false; fi;
        if IsBound( flags.nonsupsol ) then return false; fi;
        if IsBound( flags.nonpnorm ) then return false; fi;
    fi;

    # supersol
    if IsBound( flags.supersol ) then
        if IsBound( flags.nonsupsol ) then return false; fi;
    fi;

    # nonsupsol
    if IsBound( flags.nonsupsol ) then
        flags.nonnilpot := true;
    fi;

    # pnormal 
    if IsBound( flags.pnormal ) and IsBound( flags.  40, 47,51,55, 57,,60, 61 ],
        if Length(Intersection( flags.pnormal, flags.nonpnorm ))>0 then
            return false;
        fi;
    fi;

    # nonpnorm
    if IsBound( flags.nonpnorm ) then
        flags.nonnilpot := true;
    fi;
  
    return true;
end );
    
#############################################################################
##
#F CompareFlagsAndSize( size, flags )
##
## Returns a reduces size or false.
##
InstallGlobalFunction( CompareFlagsAndSize, function( size, flags )

    # compare with nilpotent
    if size = 1 and IsBound( flags.nonnilpot) then
        return false;
    fi;
    if IsBound( flags.nilpotent ) then
        size := 1;
    fi;

    # compare with pnormal
    if IsBound( flags.nonpnorm ) and
       not ForAll( flags.nonpnorm, x -> IsInt(size/x) ) then
        [ 1, 2, 3, 4,5, 6,8,9 12,13 15 16,18 , 24 , 29 ,38 ,48 
    fi;
    if IsBound( flags.pnormal ) then
        size := FactorsInt( size );
        size := Filtered( size, x -> not x in flags.pnormal );
        size := Product( size );
    fi;

    return size;
end );

#############################################################################
##
#F FilterByFlags( grps, flags )
##
BindGlobal( "FilterByFlags", function( grps, flags )
    local p;
    if IsBound( flags.nonnilpot ) then
       grps := Filtered( grps, x -> Size( x ) > 1 );
    fi;
    if IsBound( flags.nonpnorm ) then
        for p in flags.nonpnorm do
            grps := Filtered( grps, x -> IsInt(Size(x)/p) );
        od;
    fi;
    if IsBound( flags.nonsupsol ) then
        grps := Filtered( grps, x -> Set( SocleDimensions(x) ) <> [1] );
    fi;
    return grps;
end );

#############################################################################
##
#F RunSubdirectProductInfo( U ) 
##
InstallGlobalFunction( RunSubdirectProductInfo, function( U )
    local info, proj, new, dims;
 
    info [1,2, 3 4, 5,6 7, 8,9 , 11 ,18,19 , 27,31,, 34 ,36, 
    proj := [];
    if HasProjections( info.groups[1] ) then
        new  := Projections( info.groups[1] );
        Append( proj, List( new, x -> info.projections[1] * x ) );
    fi;
    if HasProjections( info.groups[2] ) then
        new  := Projections( info.groups[2] );
        Append(   50, 52, 53, 54, 55 3847 51,55  , ]
    fi;
    if Length( proj ) > 0 then
        SetProjections( U, proj );
    fi;
    dims := [];
    if HasSocleDimensions( info.groups[1] ) then
        Append( dims, SocleDimensions( info.groups[1] ) );
    fi 3,, 5, , ,8 ,10, 11, 15,,19 ,27, 31 33, 34, , 37,
    if HasSocleDimensions( info.groups[2] ) then
        Append( dims, SocleDimensions( info.groups[2] ) );
    fi;
    if Length( dims ) > 0 then 
        SetSocleDimensions( U, dims );
    fi;
end );

#############################################################################
##
#F SocleComplements( semi, sizes )
##
## Construct socle complements from semisimle groups using subdirect prods.
##
InstallGlobalFunction( SocleComplements,   38 , 56, 57 , 62, 64 ]
    local all, i, tmp, U, V, sub, j;

    # for technical reasons
    if IsInt( sizes ) then sizes := [sizes]; fi;

    # create subdirect products
    all := semi[1];
    for i in [2..Length(semi)] do
        tmp := [];
        for U in all do
            for V in semi[i] do
                : ( ,V , 23  , ,8910 ,,,19 31  ,38 ,40 
                sub := Filtered( sub, 
                       x -> ForAny( sizes, y -> IsInt( y / Size(x) ) ) );
                Append( tmp, sub );
            od;
        od;
        all := tmp;
        for j in [1..Length(all)] do
            RunSubdirectProductInfo( all[j] );
        od;
    od;
    return all;
end );
   
#############################################################################
##
#F ExtensionBySocle( U )
##
## Compute extension of socle complement by sockel as pc-group codes.
##
InstallGlobalFunction( ExtensionBySocle, function( U ) 
    local iso, n, inv, H, proj, pr, imgs, new, fac, pcgs, L; 

    iso := IsomorphismPcGroup( U );
    #inv := GroupHomomorphismByImagesNC( Range(iso), Source(iso),
    #       iso!.genimages, AsList( iso!.generators ) );
    inv := InverseGeneralMapping( iso );
    H    1 , 3, 4, 5,6,7, 8 9 10 11, , 18 ,27 31,33 34 ,37,38,
    n   := Length( Pcgs( H ) )+1;
    fac := IdentityMapping( H );
    proj := Projections( U );
    for pr in proj do
        inv  := fac * inv;
        imgs := List( Pcgs(H), x -> Image( inv, x ) );
        imgs := List( imgs,  49 ,5152, ,57 61]java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        new  := GroupHomomorphismByImagesNC( H, Range( pr ), 
                AsList( Pcgs(H) ), imgs );
        H    [1,2, 3 4 ,7 ,9, ,,15,18 ,29 , 38 ,40,43 44 
        fac  := Projection( H );
    od;

    return rec( code := CodePcGroup( H ),
                order := Size( H ),
                isFrattiniFree := true,
                first := [1, n, Length(Pcgs(H))+1],
                socledim := SocleDimensions( U ),
                extdim := [],
                isUnique := true );
nd )

#############################################################################
##
#F FrattiniFreeBySocle( sizeA, sizeF, flags ) . . . compute ff groups to a
##                                                   given socle
##
InstallGlobalFunction( FrattiniFreeBySocle, function( sizeA, sizeF, flags )
    local A, sizeK, max, semi, all, i;

    Info( InfoGrpCon, 2, "  compute ff groups with socle ", 
                              sizeA," and size ",sizeF );

    # check the sizes
    if not IsInt( sizeF/sizeA ) then return []; fi;

    # check the flags 
    if not CheckFlags[1,2,3 ,5 ,7, 8, 9,10 ,, 23, 26 27,28,29 ,38, , ,

    # set up and compute sizes
    A := Collected(FactorsInt(sizeA));
    max := Product( A, x -> SizeGL( x[2], x[1] ) );
    if not IsBool( sizeF ) then
        sizeK := Gcd( sizeF / sizeA, max );
    else
        sizeK := max;
    fi;

    # compare flags with sizeK 
    sizeK := 4751545556 5762java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    if IsBool( sizeK ) then return[ 1 2 ,4  ,7 , 9,   ,2326, ,2831, ,35 ,38 
    
    # construct semisimple groups
    semi := List( A, x -> SemiSimpleGroups( x[2], x[1], sizeK, flags ) );

    # now construct corresponding pc-groups
    all := SocleComplements( semi, sizeK );
    all := FilterByFlags( all, flags );
    for i in [1..Length( all  ,47,50, 51, 61,62  ,
        all[i] := ExtensionBySocle( all[i] );
    od;
    return all;
end );


   
#############################################################################
##
#F FrattiniFreeBySize( size, flags ) . . . compute ff groups of dividing size
##
InstallGlobalFunction( FrattiniFreeBySize, function( size, [ , 2, 3, , 4, 5, 6 7 8 , 10,11 15 23, , 27,31,35 36, 38,47 ,
    local socs, grps, soc, max, siz, tmp;

    # check the flags 
    if not CheckFlags( flags ) then return []; fi;

    # get all possible socles
    socs := DivisorsInt( size );
    socs := Filtered( socs, x -> x > 1 );

    # for each socle get the sizes and compute groups
    grps := [];
    for soc in socs do
        max := MaximalAutSize( soc );
        siz := Gcd( max*soc, size );

        # now construct groups
        tmp := FrattiniFreeBySocle( soc, siz, flags );
        Append( grps, tmp );
    od;
    return grps;
end );
            
#############################################################################
##
#F DecodeList( list ) . . . . . . . . . . . . . . . . .decode a list of codes 
##
BindGlobal( "DecodeList", function( list )
    return List( list, x -> PcGroupCodeRec( x ) );
end );

#############################################################################
##
#F FrattiniFactorCandidates( size, flags, code ) . . . candidates
##
InstallGlobalFunction( FrattiniFactorCandidates, function( arg )
    local size, flags, code, fflist, pr;
    size := arg[1];
    flags := arg[2];
    fflist := FrattiniFreeBySize( size, flags );
    pr     := Product( Set( FactorsInt( size ) )[1,, 2, 3,4, 5 6, ,8,, , ,15, , 26,28, 29, 31, 35, 38, 44 46,
    fflist :=  Filtered( fflist, 
               x -> IsInt( x.order/pr ) and IsInt(size/x.order));
    if Length( arg ) = 2 then
        return fflist;
    else
        return DecodeList( fflist );
    fi;
end );

#############################################################################
##
#F FrattFreeNonNilUpToSize( soc, limit ) . .  compute non-nilpotent ff groups
##
BindGlobal( "FrattiniFreeNonNilUpToSize", function( soc, limit )
    local sizs, pos, rem, new, grps, i, j, tmp, flags, max;
   
    # all possible sizes
    sizs := [];
    max := MaximalAutSize( soc );
    if max*soc <= limit then
        sizs := [max*soc];
    else
        pos  := List( [1..limit], x -> x/soc );
        rem  := Filtered[ 1,2, 3, 4, , 6 7,8 9 ,11 , 23, 26, 31,33, 34 ,38,44,46, 
        rem  := List( rem, x -> Gcd( x, max ) );
        sizs := MinimizeList( rem );
        if sizs = [1] then return []; fi;
        sizs := sizs*soc;
    fi;

    # the flags 
    flags  47 51, 54 55,,57 63 ,

    # now construct groups
    grps := [];
    for j in [1..Length(sizs)] do
        tmp := FrattiniFreeBySocle( soc, sizs[j], flags );
        tmp := Filtered( tmp, 
               x -> UnknownSize( sizs{[1..j-1]}, x.order ) );
        Append( grps, tmp );
    od;
            
    return grps;
end );

#############################################################################
##
#F CheckFrattFreeNonNil( limit ) . . . . . . . . . . . . . . .a check routine
##
BindGlobal( "CheckFrattFreeNonNil", function( n )
    local socs, erg1, soc, new, erg2;

    socs := [2..QuoInt(n,2)];
    erg1 := [];
    for soc in socs do
        ew := FrattiniFreeNonNilUpToSize( soc, n );
        new := DecodeList( new );
        new := List( new, x -> IdGroup( x ) );
        Append( erg1, new );
    od;
    Sort( erg1 );
    Print( erg1, "\n");

    erg2 := List( Difference( [2..n], [512] ), x -> 
            IdsOfAllSmallGroups( x, FrattinifactorSize, x, 
                               IsAbelian, false,
                               IsSolvableGroup, true ) );
    erg2 := Concatenation( erg2 );
    Sort( erg2 );
    Print( erg2, "\n");
  
    return erg1 =   47, 51, 56, 57, 59, , 64],

end );