#############################################################################
##
#W lazy.gi   RDS Package  Marc Roeder
##
##  Some black-box functions for quick-and-dirty claculations
##
##
#Y  Copyright (C) 2006-2011 Marc Roeder 
#Y 
#Y This program is free software; you can redistribute it and/or 
#Y modify it under the terms of the GNU General Public License 
#Y as published by the Free Software Foundation; either version 2 
#Y of the License, or (at your option) any later version. 
#Y 
#Y This program is distributed in the hope that it will be useful, 
#Y but WITHOUT ANY WARRANTY; without even the implied warranty of 
#Y MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
#Y GNU General Public License for more details. 
#Y 
#Y You should have received a copy of the GNU General Public License 
#Y along with this program; if not, write to the Free Software 
#Y Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
##
#############################################################################
##
#O IsDiffset(<diffset>,[<forbidden>],<Gdata>,[<lambda>])
##
InstallMethod(IsDiffset,[IsDenseList,IsRecord],
        function(diffset,Gdata)
    return IsDiffset(diffset,[],Gdata,1);
end);

InstallMethod(IsDiffset,[IsDenseList,IsRecord,IsPosInt],
        function(diffset,Gdata,lambda)
    return IsDiffset(diffset,[],Gdata,lambda);
end);

InstallMethod(IsDiffset,[IsDenseList,IsDenseList,IsRecord],
        function(diffset,forbidden,Gdata)
    return IsDiffset(diffset,forbidden,Gdata,1);
end);

InstallMethod(IsDiffset,[IsDenseList,IsDenseList,IsRecord,IsPosInt],
        function(diffset,forbidden,Gdata,lambda)
    local   pres;
    if not IsSubset([1..Size(Gdata.Glist)],Union(forbidden,diffset))
       then
       Error("<forbidden> and <diffset> must consist of integers less than the group size"); 
    fi;
    pres:=Collected(AllPresentables(diffset,Gdata));
    if Set(pres,i->i[1])=Difference([2..Size(Gdata.Glist)],forbidden) 
       and Set(pres,i->i[2])=[lambda]
       then
        return true;
    else
        return false;
    fi;
end);

#############################################################################
##
#O IsPartialDiffset(<diffset>,[<forbidden>],<Gdata>,[<lambda>])
##
InstallMethod(IsPartialDiffset,[IsDenseList,IsRecord],
        function(diffset,Gdata)
    return IsPartialDiffset(diffset,[],Gdata,1);
end);

InstallMethod(IsPartialDiffset,[IsDenseList,IsRecord,IsPosInt],
        function(diffset,Gdata,lambda)
    return IsPartialDiffset(diffset,[],Gdata,lambda);
end);

InstallMethod(IsPartialDiffset,[IsDenseList,IsDenseList,IsRecord],
        function(diffset,forbidden,Gdata)
    return IsPartialDiffset(diffset,forbidden,Gdata,1);
end);

InstallMethod(IsPartialDiffset,[IsDenseList,IsDenseList,IsRecord,IsPosInt],
        function(diffset,forbidden,Gdata,lambda)
    local   pres;
    if not IsSubset([1..Size(Gdata.Glist)],Union(forbidden,diffset))
       then
       Error("<forbidden> and <diffset> must consist of integers less than the group size"); 
    fi;
    pres:=Collected(AllPresentables(diffset,Gdata));
    if IsSubset(Difference([2..Size(Gdata.Glist)],forbidden),Set(pres,i->i[1])) 
       and Set(pres,i->i[2])<=[lambda]
       then
        return true;
    else
        return false;
    fi;
end);


#############################################################################
##
#O IsDiffset(<diffset>,[<forbidden>],<group>,[<lambda>])
##
InstallMethod(IsDiffset,[IsDenseList,IsGroup],
        function(diffset,group)
    return IsDiffset(diffset,[],group,1);
end);

InstallMethod(IsDiffset,[IsDenseList,IsGroup,IsPosInt],
        function(diffset,group,lambda)
    return IsDiffset(diffset,[],group,lambda);
end);

InstallMethod(IsDiffset,[IsDenseList,IsDenseList,IsGroup],
        function(diffset,forbidden,group)
    return IsDiffset(diffset,forbidden,group,1);
end);

InstallMethod(IsDiffset,[IsDenseList,IsDenseList,IsGroup,IsPosInt],
        function(diffset,forbidden,group,lambda)
    local   iso,  Gdata;
    if not (IsSubset(group,forbidden) and IsSubset(group,diffset))
       then
        Error("<forbidden> and <diffset> must be contained in <group>");
    fi;
    if Set(group)[1]<>One(group)
       then
        iso:=IsomorphismPermGroup(group);
    else
        iso:=IdentityMapping(group);
    fi;
    Gdata:=PermutationRepForDiffsetCalculations(Image(iso));
    return IsDiffset(GroupList2PermList(Image(iso,diffset),Gdata),
                   Set(GroupList2PermList(Image(iso,forbidden),Gdata)),
                   Gdata,
                   lambda);
end);



#############################################################################
##
#O IsPartialDiffset(<diffset>,[<forbidden>],<group>,[<lambda>])
##
InstallMethod(IsPartialDiffset,[IsDenseList,IsGroup],
        function(diffset,group)
    return IsPartialDiffset(diffset,[],group,1);
end);

InstallMethod(IsPartialDiffset,[IsDenseList,IsGroup,IsPosInt],
        function(diffset,group,lambda)
    return IsPartialDiffset(diffset,[],group,lambda);
end);

InstallMethod(IsPartialDiffset,[IsDenseList,IsDenseList,IsGroup],
        function(diffset,forbidden,group)
    return IsPartialDiffset(diffset,forbidden,group,1);
end);

InstallMethod(IsPartialDiffset,[IsDenseList,IsDenseList,IsGroup,IsPosInt],
        function(diffset,forbidden,group,lambda)
    local   iso,  Gdata;
    if not (IsSubset(group,forbidden) and IsSubset(group,diffset))
       then
        Error("<forbidden> and <diffset> must be contained in <group>");
    fi;
    if Set(group)[1]<>One(group)
       then
        iso:=IsomorphismPermGroup(group);
    else
        iso:=IdentityMapping(group);
    fi;
    Gdata:=PermutationRepForDiffsetCalculations(Image(iso));
    return IsPartialDiffset(GroupList2PermList(Image(iso,diffset),Gdata),
                   Set(GroupList2PermList(Image(iso,forbidden),Gdata)),
                   Gdata,
                   lambda);
end);


#############################################################################
##
#F StartsetsInCoset(<ssets>,<coset>,<forbiddenSet>,<aim>,<autlist>,<sigdat>,<data>,<lambda>)
##
InstallGlobalFunction("StartsetsInCoset",
        function(ssets,coset,forbiddenSet,aim,autlist,sigdat,Gdata,lambda)
    local   Np,  cosetP,  localssets,  comps,  timetmp,  partfunc;
    
    if IsListOfIntegers(forbiddenSet)
       then
        Np:=Set(forbiddenSet);
    elif IsSubset(Gdata.G,forbiddenSet)
      then
        Np:=GroupList2PermList(Set(forbiddenSet),Gdata);
    else
        Error("forbidden set has the wrong form!");
    fi;
    if IsListOfIntegers(coset)
      then
        cosetP:=coset;
    elif IsSubset(Gdata.G,coset)
      then
        cosetP:=GroupList2PermList(Set(coset),Gdata);
    else
        Error("normal subgroup has the wrong form!");
    fi;
        if not (IsInt(aim) and IsDenseList(autlist) and IsList(sigdat) and ForAll(sigdat,IsRecord))
       then
        Error("at least one of aim/autlist/sigdat is o wrong type");
    fi;
    if ssets<>[] and Size(ssets[1])>=aim 
       then 
        Error("startsets already too large!");
    elif ssets<>[] and not Size(Set(ssets,Size))=1
      then
        Error("startsets are not of the same size");
    fi;
       
    if not ForAll(ssets,IsListOfIntegers) and ForAll(ssets,s->IsSubset(Gdata.Glist,s))
       then
        localssets:=List(ssets,s->GroupList2PermList(s,Gdata));
    elif ForAll(ssets,IsListOfIntegers)    
      then
        localssets:=StructuralCopy(ssets);
    fi;
    
    if not (IsInt(lambda) and 1<=lambda)
       then 
        Error("lambda must be an integer >=1");
    fi;
    
    if lambda>1 
       then
        partfunc:=function(set)
            local   multiplicities,  siginvar;
            multiplicities:=List(Collected(AllPresentables(set,Gdata)),i->i[2]);
            siginvar:=SigInvariant(Union(set,[1]),sigdat);
            return [Collected(multiplicities),siginvar];
        end;
    else
        partfunc:=function(set)
            return SigInvariant(Union(set,[1]),sigdat);
        end;
    fi;
    
    ## and now for the calculations:
    
    comps:=Difference(cosetP,Np); #the set of possible completions
#Y#Y You should have received a copy of the GNU General Public License 
       then#Y Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
        fset(<diffset>,[##
    elif ForAll(localssets,s->otsSize(s)]in cosetP)
      then                        #raise startset length by 1, disregarding
        if lambda=1               # ordering of G.
           then
            =(localssets,omps,p,,)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
        else
            localssets:=ExtendedStartsetsNoSort(localssets,omps,,,Gdatalambda)java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 86
        ;
    elif ForAll(localssets,s->s[java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 7
                         
    else                          # we do nothing here
        (t  look ";
    ;
    localssets:(,utlist,partfuncGdata.iffTable;
            
    #now startsets are completed using the ordering of G
      l>1thereisa specialfunction.
    
    if lambda=1
       then
        ##
          do
            timetmp:=Runtime();
            localssets:=ExtendedStartsets(localssets,comps,Np,aim,Gdata);
            localssets:=ReducedStartsets(localssets,autlist,partfunc,Gdata.diffTable);
            Info(InfoRDS,1,"-->",Size(localssets)," @", StringTime(Runtime()-timetmp));
        od;
    else
        while localssets<>[] and Size(localssetsreturn IsPartialDiffsetdiffset[,,1)
          do
            ()java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
            localssets:=xtendedStartsets(ocalssets,comps,Np,aim,Gdata,lambda);
            localssets:=ReducedStartsets(localssets,autlist,partfunc,Gdata.diffTable);
            InfoI,1"-"Sizel)"@, ()-))
        
    ;
;
end




#############################################################################
##
#F SignatureData(<Gdata>,<globalSigData>,<forbiddenSet>,k,lambda,maxtest)
##
java.lang.StringIndexOutOfBoundsException: Range [4, 2) out of bounds for length 7

    
    moretest,discardedGlobalData,  normals;
not IsRecord() IsInt(k  IsInt() IsInt(axtest)
       thenreturn true;
        " type of ")java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    fi#O IsDiffset(<diffset>,[<forbidden>],<group>,[<lambda>])
    moretest:t;
    discardedGlobalData:=[];
    normals:=Filtered(NormalSubgroups(Gdata.G),g)
    
end);


#############################################################################
##
#F NormalSgsHavingAtMostKSigs(<sigdata>,<n>,<lengthlist>)
##
java.lang.StringIndexOutOfBoundsException: Range [19, 5) out of bounds for length 27
        function(sigdat,n,java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 2
          
     (Filtereds,s-Size(sigs<nand 1)in lengthlist)i->ec(ubgroup:i.subgroup,sigs=.sigs);
end


#############################################################################
##
#F SuitableAutomorphismsForReduction(<Gdata>,<normalsg>)
##
##
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
d,orbidden,)
    local     IsPartialDiffsetdiffset,forbidden,1;
    
    cosets=RightCosetsGdata.normalsg);
    Apply(,c-(etc),data)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    return[ntersection(Set(,>(Gdata.,,nSets));
end);


#############################################################################
##
#E  END
##