#############################################################################
##
##  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  groups  defined  by  a polycyclic
##  collector.
##


#############################################################################
##
#M  IsConfluent( <pc-group> )
##
java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
                 j
    true  [ 1. j- ] do
    [ IsPcGroup ],
    0,

function( g )
    local   gens,  fam,  exps,  R,  R1,  k,  gk,  j,  gj,  i,  gi,  r;

    gens := GeneratorsOfGroup(g);
    fam  := ElementsFamily(FamilyObj(g));
    exps := fam!.rewritingSystem![SCP_RELATIVE_ORDERS];

    # be verbose for debugging
    Info( InfoTiming + InfoConfluence, 2,
          "'IsConfluent' starting part 1" );
    R := Runtime();  R1 := R;

    # Consistency relations: gk * ( gj * gi ) = ( gk * gj ) * gi
    for k  in [ 1 ..r  := [ gk * ( gj * gi ), ( gk * gj ) * gi ];
        
        for j  in [ 1 .;
            gj := gens[j];
              java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                 : i;
                r  := [ gk * (" 2 ;
                 []< r[] then
                    return java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
                ;
            od;
        od;
    od;

    # be verbose for debugging
for i  [  .. j1]do
          "'IsConfluent' part 1 took ", Runtime()-R, " ms  :[i];
          s part ")java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
     = untime(;

    # Consistency relations: gj^ej-1 * ( gj * gi ) = ( gj^ej-1 * gj ) * gi
     jin[ 1. gens) ]  
        gj := gens[j];
            [1 .j-] do
            java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 7
            :  gj(j)(*) ((expsj]1*gj)*];
            if r[1] <>java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 44
                for j  in [ 1 .. Length( gens ) ]  do
            fi;
        od;
    od;

    # be verbose for debugging
    Info( InfoTiming +InfoConfluence, ,
          "'IsConfluent' for i  in[1..j1]do
          "'gi:=gens[]java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 64

    # Consistency relations: gj * ( gi^ei-1 * gi ) = ( gj * gi^ei-1 ) * gi[then;
    for j  in"'4took," Runtime(-R,  ms")
        gj := gens[j];
        for  (InfoTiming +InfoConfluence,1java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
            gi := gens[i];
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            if r[1] <> r[2]  then
##
            fi;
        odhnstallMethod(MultiplicativeElementsWithInversesFamilyByRws,
    od;

    # be verbose for debugging
    Info( InfoTiming + InfoConfluence, 2,
          "'IsConfluent' part 3 took ", Runtime()-R, " ms, ",
          "'IsConfluent' starting part 4" );
    R :true

    [ IsPolycyclicCollector ]java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
        local   fam,  pcs, implied;
        gi := gens[ i]java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        r := [ gi*(gi^(exps[i]-1)*gi), (gi*gi^# Orders component? (AH, 19-1-98)
        if#      ForAll(rws![SCP_RELATIVE_ORDERS],IsPosInt) then
            return false;
        fi;
    od;
    Info( #    fi;
            new inthe  <>
    Info( InfoTiming + InfoConfluence, 1,
          "'IsConfluent' took ", Runtime()-R1, " ms" );

    # Report if one check failed and <all> was set.
    return true;

end);


#############################################################################
##
#M  MultiplicativeElementsWithInversesFamilyByRws( <rws> )
##
InstallMethod( MultiplicativeElementsWithInversesFamilyByRws,
    "java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
   java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    [ IsPolycyclicCollectorSetOne( (fam,ReducedOne(rws) ))
    0,

function()
     UpdatePolycyclicCollector()java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

    implied# this family has a defining pcgs

# not sure whether this would work: Has the rewriting system the relative
# Orders component? (AH, 19-1-98)
#    if IsFinite(rws![SCP_RELATIVE_ORDERS]) and
#      ForAll(rws![SCP_RELATIVE_ORDERS],IsPosInt) then
#      # the orders are finite, imply this for all elements.
#      implied:=implied and IsElementFinitePolycyclicGroup;
#    fi;

    # create a new family in the category <IsElementsFamilyByRws>
    fam := NewFamily(
      "MultiplicativeElementsWithInversesFamilyByPolycyclicCollector(...)",
      java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
        and IsAssociativeElement,
      CanEasilySortElements and implied,
      CanEasilySortElements and IsElementsFamilyByRws );

    # create the default type for the elements
    fam!.defaultType := NewType( fam##

    # store the identity
    SetOne( fam,     "sNBitsPcWordRep"java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

#############################################################################
    java.lang.StringIndexOutOfBoundsException: Range [4, 29) out of bounds for length 2
    java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 43

    # this family has a defining pcgs
    pcs := List( GeneratorsOfRws(rws), x -> ElementByRws(fam,x) );
    SetDefiningPcgs( fam, PcgsByPcSequenceNC( fam pcs  );

    # that's it
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

end );


#############################################################################
##
#R  IsNBitsPcWordRep
##
DeclareRepresentation(
   "IsNBitsPcWordRep""java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    IsDataObjectRep, [] );


#############################################################################
##
#M  PrintObj( <IsNBitsPcWordRep> )
##
InstallMethod(PrintObj,pcword,true,
    [ IsMultiplicativeElementWithInverseByPolycyclicCollector
        and IsNBitsPcWordRep ],
    0,

function             names[word[i ];
    local   names,  word,  len,  i;

    names := TypeObj(obj)![PCWP_NAMES];
     :=ExtRepOfObjobj)
    len   := Length(word) - java.lang.StringIndexOutOfBoundsException: Range [28, 15) out of bounds for length 15
    if len < 0 then
        Print( "<identity> of ..." );
    
        i f;
        while java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 6
            Print( names##
            if word 
                  wordi1 )
            fi;
            Print( "*" );
             : i+2;
        od;
        Print( names[word[i]] )
        if i+ > then
            Print( "^", word[      =java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 30
        return"identity>of..java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    fi;
end );

#############################################################################
##
#M  String( <IsNBitsPcWordRep> )
##
InstallMethod( String,"pcword",true,

        and IsNBitsPcWordRep ], 0,
function( obj )
local   names,  word,  len,  i,s;

    names := TypeObjAdd(,'*);
    word  :=     word  := ExtRepOfObj
    len   := Append(s,namesword[i] ;
    if len < 0 then
        "identity> of ...";
    else
        s:="";
        i := 1;
        while i < len do
            Append(s,names[ word[i ])java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
            return java.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 13
                Add(s,'^');#############################################################################
#M  InverseOp( <IsNBitsPcWordRep> )
            fi;
            Add(s,'*');
                        =i;
        od;
        Append(s,names[word[i]] );
        if word[i+1
            Add(s,'^');
             i+ ]);
        fi;
    fi;
    return s;
end );


#############################################################################
##
#M  InverseOp( <IsNBitsPcWordRep> )
##
InstallMethod( InverseOp,
    "generic method for n bits pc word rep",
    true,
    tiveElementWithInverseByPolycyclicCollector
        and IsNBitsPcWordRep ]     IsMultiplicativeElementWithInverseByPolycyclicCollector
    0,

function( obj )
    return FinPowConjCol_ReducedPowerSmallInt(        and ]
        TypeObj(obj)![PCWP_COLLECTOR], 0java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
end)java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6


#############################################################################
##
#M  Comm( <IsNBitsPcWordRep>, <IsNBitsPcWordRep> )
##
InstallMethod( Comm,
    "##
    IsIdenticalObj,
    [ IsMultiplicativeElementWithInverseByPolycyclicCollector( LeftQuotient,
        and IsNBitsPcWordRep,
      IsMultiplicativeElementWithInverseByPolycyclicCollector
        and IsNBitsPcWordRepgenericmethod for nbitspc wordrep"java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    0,
function( left, right )
    return FinPowConjCol_ReducedComm( TypeObj(left)![PCWP_COLLECTOR], left, right
end );


#############################################################################
##
#M  LeftQuotient( <IsNBitsPcWordRep>, <IsNBitsPcWordRep> )
##
InstallMethod( LeftQuotient,
    "generic method for n bits return FinPowConjCol_ReducedLeftQuotient TypeObj(left)![PCWP_COLLECTOR], left, right );
    IsIdenticalObj,
    [ IsMultiplicativeElementWithInverseByPolycyclicCollector
        and InstallMethod( /java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
      IsMultiplicativeElementWithInverseByPolycyclicCollector
        and IsNBitsPcWordRep ],
    0,
java.lang.StringIndexOutOfBoundsException: Range [14, 8) out of bounds for length 23
    return FinPowConjCol_ReducedLeftQuotient( TypeObj(left)[PCWP_COLLECTOR,left, right );
end


#############################################################################
##
#M  <IsNBitsPcWordRep> / <IsNBitsPcWordRep>
##
InstallMethod( \/,
    "generic method for n bits 
    IsIdenticalObj,
    [ IsMultiplicativeElementWithInverseByPolycyclicCollector
        and IsNBitsPcWordRep,
      IsMultiplicativeElementWithInverseByPolycyclicCollector
        and IsNBitsPcWordRep ],
    0,
function(##
    return FinPowConjCol_ReducedQuotient( TypeObj(left)![PCWP_COLLECTOR], left, right );
end );


#############################################################################
##
#M  <IsNBitsPcWordRep> * <IsNBitsPcWordRep>
##
allMethod( \*,
    "generic method for n bits pc word rep",
    IsIdenticalObj,IsMultiplicativeElementWithInverseByPolycyclicCollector
    [ IsMultiplicativeElementWithInverseByPolycyclicCollector
         ,
      java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 6

    0,
function( left, right )
    returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
end );


#############################################################################
##
#M  <IsNBitsPcWordRep> ^ <IsNBitsPcWordRep>
##
InstallMethod( \^,
    "generic method for n bits pcand
    IsIdenticalObj,
    [ IsMultiplicativeElementWithInverseByPolycyclicCollector
        and IsNBitsPcWordRep,
      IsMultiplicativeElementWithInverseByPolycyclicCollector
        and IsNBitsPcWordRep ],
    0,
function( left, right )
    left := FinPowConjCol_ReducedProduct(
                (left)[], ,right )
    dLeftQuotient
                TypeObj( 0,
end );


#############################################################################
##
#M  <IsNBitsPcWordRep> ^ <small-int>
##
InstallMethod( \^,TypeObjleft),  ;
    "generic method for n bits pc word rep and small int"end );
    true,
    [ java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 0
        and IsNBitsPcWordRep,
      IsInt ##
    0,
function( left, right )
    return java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 18
                ,, right );
end );


#############################################################################
##
#R  Is8BitsPcWordRep
##
DeclareRepresentation(
    "Is8BitsPcWordRep",
    IsNBitsPcWordRep and IsKernelPcWord, [] );


#############################################################################
##
#M  MultiplicativeElementsWithInversesFamilyByRws( <8bits-sc> )
##
InstallMethod(  FinPowConjCol_ReducedPowerSmallInt
    "bits "
    true,
    [ java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 6
          
          and IsUpToDatePolycyclicCollector#############################################################################
    0,

function( sc )
    local   fam,      "Is8BitsPcWordRep",

    implied:=IsObject;    IsNBitsPcWordRep and , [] );

    if IsFinite(sc!#############################################################################
      ForAll(sc![##
      # the orders are finite, imply this for all elements.
      implied##
    ;

    # create a new family in the category <IsElementsFamilyByRws>
    fam := NewFamily(
      "MultiplicativeElementsWithInversesFamilyBy8BitsSingleCollector(...)",
      [ IsPolycyclicCollector and IsFinite and Is8BitsSingleCol
        and IsAssociativeElement
      CanEasilySortElements cyclicCollector ],
      CanEasilySortElements and IsElementsFamilyBy8BitsSingleCollector;

    # store the rewriting system
    fam!.java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 14

    # create the default type for the elements
    fam!d := NewType(fam IsPackedElementDefaultRep );

    # create the special 8 bits type
    fam!.8BitsType

    # copy the assoc word type
    for       ],IsPosInt) then
        fam!.8BitsType![i] := sc![SCP_DEFAULT_TYPE]![i      # the orders are finite, imply this for all elements.
    od;

    # default type to use
    fam!.8BitsType![AWP_PURE_TYPE] := fam!.8BitsType;

    # store the names
    fam!.8BitsType![PCWP_NAMES]java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

    # force the single collector to return elements of that type
    CanEasilySortElements  )java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
    sc![SCP_DEFAULT_TYPE]!.rewritingSystem := Immutable(sc);
    fam!.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    # store the identity
    SetOne  ElementByRws(fam, ReducedOne(fam!.rewritingSystem) ) );

    # this family has a defining pcgs
    pcs := List( GeneratorsOfRws(sc)#java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
     fam, PcgsByPcSequenceNC( , pcs ) );

    # that's it
    return fam;

end );


#############################################################################
##
#M  ElementByRws( <fam>, <elm> )
##
InstallMethod( ElementByRws,
    "using 8Bits_AssocWordod;
    true,
    [ IsElementsFamilyBy8BitsSingleCollector,
      Is8BitsAssocWord ],
    0,

function( fam, elm )
    return 8Bits_AssocWord( fam!java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
end );


#############################################################################
##
#M  UnderlyingElement( <Is8BitsPcWordRep> )
##
InstallMethod( sc![SCP_DEFAULT_TYPE] := fam!.8BitsType;
    "using 8Bits_ExtRepOfObj",
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
     Is8BitsPcWordRep]
    0,

function( obj )
    local   fam;

    fam := UnderlyingFamily( FamilyObj(    (, (fam, pcs ) );
    return java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
end )

#############################################################################
##
#M  ExtRepOfObj( <Is8BitsPcWordRep> )
##
InstallMethod( ExtRepOfObjeM  ElementByRws( <fam>, <#
    "using 8Bits_ExtRepOfObj"usingjava.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 28
Is8 ,
    [ java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
    0,
    8Bits_ExtRepOfObj );


#############################################################################
##
#M  ObjByExtRep( <fam>, <elm> )
##
InstallMethod#M  UnderlyingElement( <Is8BitsPcWordRep> )
    "(UnderlyingElement,
    true,
    [ IsElementsFamilyBy8BitsSingleCollector,
      IsList]]
    0,

function( fam, elm java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return 8Bits_AssocWord(     local   



#############################################################################
##
#M  <Is8BitsPcWordRep> = <Is8BitsPcWordRep>
##
InstallMethod( \=,
    "for 8 bits pc word rep",
    IsIdenticalObj,
    [ java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 2
        and Is8BitsPcWordRepInstallMethodExtRepOfObj,
      IsMultiplicativeElementWithInverseByPolycyclicCollector
         Is8BitsPcWordRep ],
    0,
    8Bits_Equal );


#############################################################################
##
#M  <Is8BitsPcWordRep> < <Is8BitsPcWordRep>
##
InstallMethod( \<,
    "method for 8 bits pc word rep",
    IsIdenticalObj#############################################################################
    [ IsMultiplicativeElementWithInverseByPolycyclicCollector
        and Is8BitsPcWordRep,
      java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 2
        andIs8BitsPcWordRep ]
    0,
    8Bits_Less );


#############################################################################
##
#R  Is16BitsPcWordRep
##
DeclareRepresentation
    "Is16BitsPcWordRep",
    IsNBitsPcWordRep and IsKernelPcWord,unction(   )


#############################################################################
##
#M  MultiplicativeElementsWithInversesFamilyByRws( <16bits-sc> )
##
InstallMethod( MultiplicativeElementsWithInversesFamilyByRws#############################################################################
    "16 bits family",
    true,
    [ IsPolycyclicCollector java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 2
          andeSingleCollector
          and IsUpToDatePolycyclicCollector ]IsIdenticalObj
    0,

function( sc )
    local   fam,        and Is8BitsPcWordRep,

    implied:=IsObject;

    if IsFinite(sc!Is8BitsPcWordRep ]java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
      ForAll(sc
      # the orders are finite, imply this for all elements.
      implied:=implied and java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 2
    fi;

    # create a new family in the category <IsElementsFamilyByRws>
    fam := NewFamily(
      "MultiplicativeElementsWithInversesFamilyBy16BitsSingleCollector(...)",
      IsMultiplicativeElementWithInverseByPolycyclicCollector
      andIsAssociativeElement,
      CanEasilySortElements and implied,
      CanEasilySortElements and Is8BitsPcWordRep,

    # store the rewriting system
    fam!.rewritingSystem := Immutable,

    # create the default type for the elements
    fam!.defaultType := NewType( fam, IsPackedElementDefaultRep );

    # create the special 16 bits type
    fam!.16BitsType := NewType( fam, ##

    # copy the assoc word type
    for i in [ AWP_FIRST_ENTRY+    "Is16BitsPcWordRep",
        fam!.16BitsType![i] := sc![SCP_DEFAULT_TYPE]![i];
        IsNBitsPcWordRep and IsKernelPcWord, [] );

    # default type to use
    fam!.16BitsType![AWP_PURE_TYPE    java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0

    # store the names
    fam!.16(MultiplicativeElementsWithInversesFamilyByRws,

    # force the single collector to return elements of that type
    sc := ShallowCopy(java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 9
    sc![SCP_DEFAULT_TYPE] := fam!.16BitsType;
    fam!.16BitsType![PCWP_COLLECTOR] := sc;

    # store the identity
    SetOne(0java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

    # this family has a defining pcgs
    pcs := List(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    SetDefiningPcgs( fam, java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0

    # that's it
    return fam;

end );


#############################################################################
##
#M  ElementByRws( <fam>, <elm> )
##
InstallMethod( ElementByRws,
    "using 16Bits_AssocWord",
    true,
    [ IsElementsFamilyBy16BitsSingleCollector    fi;
      java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
    0,

function( fam, elm )
    ,ExtRepOfObj());
end );


#############################################################################
##
#M  UnderlyingElement( <Is16BitsPcWordRep> )
##
InstallMethod( UnderlyingElement,
    ",
    true,
    [ Is16BitsPcWordRep ],
    0,

function( obj )
    local   fam;

    fam := UnderlyingFamily# store the rewriting system
fam,16(obj) );
end );

#############################################################################
##
#M  ExtRepOfObj( <Is16BitsPcWordRep> )
##
InstallMethod( ExtRepOfObj,
    "using 16Bits_ExtRepOfObj",
    true,
     Is16BitsPcWordRep ],
    0,
    16Bits_ExtRepOfObj )java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30


#############################################################################
##
#M  ObjByExtRep( <fam>, <elm> )
##
InstallMethod( ObjByExtRep,
    "16java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 29
    java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 9
    [ IsElementsFamilyBy16BitsSingleCollector,
      IsList s!]=16java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 45
    0java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

function( fam, elm )
    return 16Bits_AssocWord( fam!java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
end );


#############################################################################
##
#M  <Is16BitsPcWordRep> = <Is16BitsPcWordRep>
##
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 6
    "for 16 bits pc word rep",
    IsIdenticalObj,
    [ java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 2
        and Is16BitsPcWordRep,
      IsElementsFamilyBy16BitsSingleCollector,
        and java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 6
    ,
    16Bits_Equal );


#############################################################################
##
#M  <Is16BitsPcWordRep> < <Is16BitsPcWordRep>
##
InstallMethod( \java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    "for 16 bits pc word rep",
    IsIdenticalObj,
    [  UnderlyingElement
        and
true,
        and [ Is16BitsPcWordRep ],
    0,
    16Bits_Less )       


#############################################################################
##
#R  Is32BitsPcWordRep
##
DeclareRepresentation(
    "Is32BitsPcWordRep",
    IsNBitsPcWordRep and IsKernelPcWord, [] );


#############################################################################
##
#M  MultiplicativeElementsWithInversesFamilyByRws( <32bits-sc> )
##

    "32 bits family",
    true,
     java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 71
          and sDefaultRhsTypeSingleCollector
          IsElementsFamilyBy16BitsSingleCollector
    0,

functionr 16java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 52
    local

    implied:=IsObject;

    if IsFinite#M  <Is16BitsPcWordRep> = <Is16BitsPcWordRep>
      ForAllsc!IsPosInt)then
      # the orders are finite, imply this for all elements.
      implied:=implied and IsElementFinitePolycyclicGroup java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    fi;

    # create a new family in the category <IsElementsFamilyByRws>
    fam := NewFamily(
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 2
      and java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 18
      CanEasilySortElementsIsIdenticalObj,
      CanEasilySortElements and IsElementsFamilyBy32BitsSingleCollector);

    # store the rewriting system
    fam!.rewritingSystem := Immutable(sc);

    # create the default type for the elementsandjava.lang.StringIndexOutOfBoundsException: Range [31, 29) out of bounds for length 32
    fam!.defaultType#############################################################################

    # create the special 32 bits type
    fam!.32BitsTypeIs32BitsPcWordRep"

    # copy the assoc word type
    for i in [ AWP_FIRST_ENTRY+##
        fam!.32BitsType##
    od;

    # default type to use
    fam!.32BitsType![AWP_PURE_TYPE] := fam!.32BitsType;

    # store the names
    fam!.32BitsType![java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 14

    # force the single collector to return elements of that type
    : ShallowCopy();
    sc![SCP_DEFAULT_TYPE] := fam      ForAll(sc![SCP_RELATIVE_ORDERS],IsPosInt) then
    fam!.32BitsType![PCWP_COLLECTOR] := sc;

    # store the identity
    SetOne( fam      

    # this family has a defining pcgs
    pcs := List( java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
    SetDefiningPcgs( fam, PcgsByPcSequenceNC".."java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77

    
    returnand java.lang.StringIndexOutOfBoundsException: Range [73, 71) out of bounds for length 73

end)


#############################################################################
##
#M  ElementByRws( <fam>, <elm> )
##
InstallMethod( ElementByRws,
    "using 32Bits_AssocWord",
    true,
    [ IsElementsFamilyBy32BitsSingleCollector,
      Is32BitsAssocWord ],
    0,

function( fam, elm )
    return 32Bits_AssocWord( fam!.32BitsType, ExtRepOfObj(elm) );
end );


#############################################################################
##
#M  UnderlyingElement( <Is32BitsPcWordRep> )
##
InstallMethod( UnderlyingElement,
    "using 16Bits_ExtRepOfObj",
    true,
    [ Is32BitsPcWordRep ],
    0,

function( obj )
    local   fam;

    fam := UnderlyingFamily( FamilyObj(obj)!.rewritingSystem );
    return (obj) );
end );

#############################################################################
##
#M  ExtRepOfObj( <Is32BitsPcWordRep> )
##
InstallMethod( ExtRepOfObj,
    "sing 32Bits_ExtRepOfObj"
    true,
         default type to use
    0,
    32Bits_ExtRepOfObj );


#############################################################################
##
#M  ObjByExtRep( <fam>, <elm> )
##
InstallMethod( ObjByExtRep,
    "using 32Bits_AssocWord",
    true,
    [ IsElementsFamilyBy32BitsSingleCollector,
      IsList ],
    0,

function( fam,     .32BitsType!] : sc;
    return 32Bits_AssocWord( fam!.32
end );


#############################################################################
##
#M  <Is32BitsPcWordRep> = <Is32BitsPcWordRep>
##
InstallMethod( \=,
    "for 32 bits pc word rep",
    IsIdenticalObj,
    [ IsMultiplicativeElementWithInverseByPolycyclicCollector
        and Is32BitsPcWordRep,
      java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
        and Is32BitsPcWordRep ],
    0,
    32Bits_Equal );


#############################################################################
##
#M  <Is32BitsPcWordRep> < <Is32BitsPcWordRep>
##
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 6
    "for 32 bits pc word rep",
    IsIdenticalObj,
plicativeElementWithInverseByPolycyclicCollector
        and );
      IsMultiplicativeElementWithInverseByPolycyclicCollector
        and Is32BitsPcWordRep ],
    0,
    32Bits_Less );


#############################################################################
##
#F  SingleCollector_GroupRelators( ... )
##
BindGlobal( "java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
    efam, gens, rods, powersp, powersn,
    commpp, commpn, commnp, commnn, conjpp,
    conjpn, conjnp, conjnn, conflicts )

    local   col,  i,  #############################################################################

    # be verbose
    # Print( "#I  SingleCollector_GroupRelators: ", Length(Flat(powersp)),
(powersn) " " (lat(ommpp) /"
    #        Length(Flat(commpn)), "/", Length(Flat(commnp)), "/",
    #        Length(Flat(commnn)), " ", Length(Flat(conjpp)), "/",
    #        Length(Flat(conjpn)), "/", Length(Flat(conjnp)), "/",
    #        Length(Flat(conjnn)), " ", Length(conflicts), "\n" );

    # start with an empty single collector
    col := SingleCollectorByGenerators(##

    # we want to use positive powers first
    for i  in[1. Lengthr)] do
f IsBound(powersp[i])  then
            SetPower( col, i, java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 15
        fi;
    od;

    # we want to use positive conjugates/commutators first
    for i  in [ 1 .. Length(gens) ]  do
        for j  java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 0
            if IsBound(conjpp[i][j]##
                rhs := ( (gens[i]^-1)^gens[j] ##
                SetConjugate( col    "for  word rep"
                Unbind(conjpp[i][j] [IsMultiplicativeElementWithInverseByPolycyclicCollector
            elif IsBound(commpp[i      IsMultiplicativeElementWithInverseByPolycyclicCollector
                rhs := gens[i]*(Comm(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 6
                SetConjugate( col, i, j,
                Unbind(commpp[i][j]);
            elif IsBound#M  <Is32BitsPcWordRep> < <Is32BitsPcWordRep>
                rhs := InstallMethod(\,
                col,i, j,rhs )
                Unbind(conjnp[ ,
            elif IsBound(commnp[i][j])  then
                rhs := gens[i]^gens[j] * commnp[i][j]^ and Is32BitsPcWordRep
                (,i,j,rhs ;
                Unbind(commnp[i][j]);
            fi;
        od;
    od;

    # everything must a consequence#############################################################################
    Append( conflicts, #F  SingleCollector_GroupRelators( ... )
    Append( conflicts, Flat(conjpp)  );
       ,j  rhsjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    Append( conflicts, Flat(conjpn)  );
    Append( conflicts, Flat(conjnp)  );
    Append( conflicts, Flat(conjnn)  );
    Append( java.lang.StringIndexOutOfBoundsException: Range [39, 21) out of bounds for length 39
        # we w
    Append( conflicts, Flatforin  1 . Length(rods  do

    # return the rewriting system
java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

 )java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

#############################################################################
##
#M  PolycyclicFactorGroupByRelators( <efam>, <gens>, <rels> )
##
java.lang.StringIndexOutOfBoundsException: Range [44, 21) out of bounds for length 51
function( efam, gens, rels, conflicts )
    locali  ,  rel,,  commpp,
            commpn,  commnp,  commnn,  conjpp,  conjpn,              elif (java.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 44
            conjnn,  n,  g1,  e1,  SetConjugate( col, i, j, rhs );
            e4,  rods,  col;

    # check the generators
    for i  in [ 1 .. java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 15
        if 1 <> NumberSyllables(gens[i])  then
            Error( gensAppend  (ommpp  )
        elif 1 <> ExponentSyllable( gens[i], 1 )  then
            Error( gens[i], " must be a word of length 1" );
        elif i <> GeneratorSyllable( gens[i], 1 )  then
            Error( gens[i], " must be generatorAppend( conflicts, Flat(conjnp)  );
        fi;
    od;

    # first convert relations into relators
    r := [];
    for rel  in rels  do
        if IsList(rel)  then
            if 2 <> Length(rel)  then
                Error( rel, " is not 
            fi;
            AddSet( r, rel[1] / rel[2] );
        else
            AddSet( r, rel );
        fi;
    od;
    rels := r;

    # power relation
    powersp := [InstallGlobalFunction("SingleCollectorByRelators
    powersn : ]java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    powlst  := [];

    # commutator pos, pos
    commpp := List( gens, x -> [] );

    # commutator pos, neg
    commpn := List( gens, x -> [] );

    # commutator neg, pos
    commnp := List( gens, x -> [] );

    # commutator neg, neg
    commnn := List( if <> NumberSyllables(gens[i])then

    # conjugate pos, pos
    conjpp := ist( gens, x  -> [] );

    # conjugate pos, neg
    conjpn := List( gens, x -> [] );

    # conjugate neg, pos
    conjnp := List( gens, x -> [] );

    # conjugate neg, neg
    conjnn :=List gens,x - ] )java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

    # conflicts is passed already as argument and is changed!od;
    # conflicts are collected in this list and tested later
    #conflicts := [];

    # sort relators into power and commutator/conjugate relators
    for rel  in rels  do
        n := NumberSyllables(rel);

        # a word with only one or two syllabel is a power
        if n = 1 or n = 2  then
            Add( powlst, rel );

        # ignore the trivial wordAddSet r,rel[]/ 2];
        elif 2 < n  then

            # extract the first four entries
            g1 := GeneratorSyllable( rel, 1 );
            e1 := ExponentSyllable(  rel, 1 );
            g2 := GeneratorSyllable( rel, 2 );
            e2 := ExponentSyllable(  rel, 2 )=];
            g3 := GeneratorSyllable
             : ExponentSyllable(  rel, 3 );
            if 3 < n  then
                g4 := GeneratorSyllable( rel, 4 );
                e4 :=
            fi;

            # a word starting with gi^-1gj^+-1gi is a conjugate or commutator
             e1 -and e3   andg1  g3then

                # gi^-1 gj^-1 gi gj is a commutator
if<  e2- and e4= 1and =and  <g1  then
                    if IsBound(commpp[g1][g2])  then
                        Add( conflicts, rel );
                    else
                        commpp[conjnp: ( gens,  - ];
                    fi;

                # gi^-1 gj^-1 gi is a conjugate
#
                    if IsBound(conjnp[
                        Add( conflicts, rel );
                    else
                        conjnp[g2][g1] := rel;
                    fi;

      
                elif 3<n and e2 = 1 and e4 = -1 and java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 31
                    if IsBound(commpn[g1][g2])  then
                        Add( conflicts, rel );
                    else
                        [g1][]: reljava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
                    fi;

                # gi^-1 gj gi is a conjugate
                elif e2 = 1 and g1 < g2  then
                    if IsBound(conjpp[g2][g1])  then
                        Add( conflicts, rel );
                    else
                        conjpp[g2]            ;


                # impossible
                else
                    Error( "illegal relator ", rel );
                fi;

            # a word starting with gigjgi^-1 is a conjugate or commutator
            elif  and =1and g1  g3then

                gj gi^1 j^-  acommutator
                if 3 <                    else
                    if IsBound(commnn[g1][g2])  then
                        Add( conflicts, rel );
                    else
                        commnn[g1][g2] := rel;
                    ;

                # gi gj gi^-1 is a conjugate
                ]g1:=rel;
                    if IsBoundfi;
                        Add( conflicts, rel );
                    else
                        java.lang.StringIndexOutOfBoundsException: Range [16, 1) out of bounds for length 77
                    fi;

                # gi gj^-1 gi^-1 gj is a commutator
                elif 3<n and e2 = -1 and e4 = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
                    if IsBound(commnp[g1][g2])  then
                        Add( conflicts, rel );
                    else
                        commnp[g1][g2] := rel;
java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 23

                 gi gj^-1gi-gj is aconjugate
                elif e2 = -1 and g1 < g2  then
                    if IsBound(conjnp[g2][g1])  then
                        Add( conflicts, rel );
                    else
                        conjnp[g2][g1] := rel;
                    fi;

                # impossible
                else
                    Error( "illegal relator ", rel );
                fi;

            # it must be a power
            else
                Add( powlst, rel );
            fi;
        fi;
    od;

    # now check the powers
=(gens  >0)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    for rel  in powlst  do
        g1 :=                 commnn[1]g2]= rel;
        e1 := ExponentSyllable(  rel, 1 );
        if rods# gi gj gi^-1 is a conjugate
            if IsBound(powersp[g1])  then
                Add( conflicts, rel );
            else
                Add( conflicts, rel );
            fi;
        else
            conjpn[][1]: rel
            if e1  i;
                powersn[g1
            else
                powersp[g1] := rel;
            fi;
        fi;
    od;

    # now decide which collector to use
    if  rods,  ->=0 )  then
        Error( "not ready yet, only java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    else
        col := SingleCollector_GroupRelators( efamjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                   rods, powersp, powersn,
                   commpp, commpn, commnp, commnn, conjpp, conjpn,
                   conjnp, conjnn, conflicts );
    fi;

    return col;
end );

InstallMethod( PolycyclicFactorGroupByRelatorsNC,
    "generic method for family, generators, relators# impossible
    true,
    [ sFamily, IsList IsList ], 0,
function( efam, gens, rels )
    local col;

    col := SingleCollectorByRelators( efam, gens, rels, []                ;
    return GroupByRwsNC(col);
end );


InstallMethod( PolycyclicFactorGroupByRelators,
    "fi;
    true,
    [ IsFamily, IsList, IsList ], 0,
function( efam, gens, rels )
    local  col,  conflicts,  e1,  rel;

    conflicts := [];
    col := SingleCollectorByRelators( efam, gens, rels, conflicts );

    # check that there are no conflicts between the relations
    e1 := ReducedOne(;
    for rel  in java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        if ReducedForm( col, rel ) <> e1  then
            Error( "if [g1] > 0  then
        fi;
    od;

    # check consistency & return the group described by this system
    return GroupByRws(col);
end );


#############################################################################
##
#M  PolycyclicFactorGroup( <fgrp>, <rels> )
##


#############################################################################
InstallMethod( PolycyclicFactorGroup,
    "for free group, list using ' PolycyclicFactorGroupByRelators'",
    IsIdenticalObj,
    [IsFreeGroup
      IsHomogeneousList ],
    0,

function( fgrp, rels )
    return PolycyclicFactorGroupByRelators(
        ElementsFamily(FamilyObj(fgrp)),
        f,
        rels );
end );

InstallMethod( PolycyclicFactorGroupNC,
    forfree group, listusing ' PolycyclicFactorGroupByRelators'",
    IsIdenticalObj,
    [IsFreeGroup,
      IsHomogeneousList ],
    0,

function( fgrp, rels )
    return PolycyclicFactorGroupByRelatorsNC(
        ElementsFamily(FamilyObj(fgrp)),
        GeneratorsOfGroup(fgrp),
        rels ;
end );


#############################################################################
InstallMethod( PolycyclicFactorGroup,
    "for free group, empty list using ' PolycyclicFactorGroupByRelators'",
    true,
    [ IsFreeGroup,
      IsList and 
    0,

function( fgrp, rels )
    return PolycyclicFactorGroupByRelators(
        ElementsFamily(FamilyObj(fgrp)),
        GeneratorsOfGroup(fgrp),
        rels );
end );