From def623d5bcdd4533322e5cb08e6d18cfceb6448c Mon Sep 17 00:00:00 2001 From: Sergio Siccha Date: Tue, 6 Apr 2021 19:03:05 +0200 Subject: [PATCH] Improve and unify names RecognitionInfoFamily -> RecogNodeFamily IsRecognitionInfo -> IsRecogNode RIFac -> ImageRecogNode RIKer -> KernelRecogNode --- doc/recognition.xml | 10 +- doc/renaming_index.xml | 4 + doc/renaming_table.xml | 22 ++- gap/base/recognition.gd | 84 ++++----- gap/base/recognition.gi | 80 ++++---- gap/generic/KnownNilpotent.gi | 4 +- gap/matrix.gi | 2 +- gap/projective/d247.gi | 4 +- misc/colva/Evaluate.g | 6 +- misc/colva/Rearrange.g | 212 +++++++++++----------- misc/colva/Refine.g | 84 ++++----- misc/colva/TopPerms.g | 36 ++-- misc/colva/leaves.g | 2 +- misc/colva/stuff.g | 12 +- tst/broken/veryslow/ClassicalNatural.tst | 4 +- tst/testclassicalnatural.g | 4 +- tst/working/quick/mixed.tst | 4 +- tst/working/veryslow/ClassicalNatural.tst | 4 +- 18 files changed, 301 insertions(+), 277 deletions(-) create mode 100644 doc/renaming_index.xml diff --git a/doc/recognition.xml b/doc/recognition.xml index 3eaba3110..94d1b9dda 100644 --- a/doc/recognition.xml +++ b/doc/recognition.xml @@ -195,19 +195,19 @@ A recognition info record is a ⪆ component object. It is a member of the family - + and is in the category - + and is , such that we can define attributes for it, the values of which are stored once they are known. A recognition info record always represents a whole binary tree of such -records, see the attributes and +records, see the attributes and below.

The following filters are defined for recognition info records: @@ -221,8 +221,8 @@ The following attributes are defined for recognition info records: <#Include Label="Homom"> <#Include Label="NiceGens"> <#Include Label="pregensfac"> -<#Include Label="RIFac"> -<#Include Label="RIKer"> +<#Include Label="ImageRecogNode"> +<#Include Label="KernelRecogNode"> <#Include Label="RIParent"> <#Include Label="fhmethsel"> <#Include Label="slpforelement"> diff --git a/doc/renaming_index.xml b/doc/renaming_index.xml new file mode 100644 index 000000000..69a16080d --- /dev/null +++ b/doc/renaming_index.xml @@ -0,0 +1,4 @@ +RecognitionInfoFamily +IsRecognitionInfo +RIFac +RIKer diff --git a/doc/renaming_table.xml b/doc/renaming_table.xml index 026db754d..74cfe3d34 100644 --- a/doc/renaming_table.xml +++ b/doc/renaming_table.xml @@ -1,9 +1,29 @@ - + Old Name New Name + + RecognitionInfoFamily + + + + + IsRecognitionInfo + + + + + RIFac + + + + + RIKer + + +
renaming of functions Renaming
diff --git a/gap/base/recognition.gd b/gap/base/recognition.gd index f93c44872..7bfe7ad45 100644 --- a/gap/base/recognition.gd +++ b/gap/base/recognition.gd @@ -17,13 +17,13 @@ ############################################################################# # The category: -DeclareCategory( "IsRecognitionInfo", IsObject ); +DeclareCategory( "IsRecogNode", IsObject ); # The family: -BindGlobal( "RecognitionInfoFamily", - NewFamily("RecognitionInfoFamily", IsRecognitionInfo)); +BindGlobal( "RecogNodeFamily", + NewFamily("RecogNodeFamily", IsRecogNode)); # The type: BindGlobal( "RecognitionInfoType", - NewType(RecognitionInfoFamily, IsRecognitionInfo and IsAttributeStoringRep)); + NewType(RecogNodeFamily, IsRecogNode and IsAttributeStoringRep)); # The info class: @@ -45,7 +45,7 @@ BindGlobal( "RECOG", rec() ); ## ## This flag indicates, whether or not a recognition info record represents a leaf ## in the recognition tree. If it is not set, one finds at least one of -## the attributes and set for +## the attributes and set for ## the corresponding node. This flag is normally reset and has to be set ## by a find homomorphism method to indicate a leaf. ## @@ -80,7 +80,7 @@ DeclareFilter( "IsReady" ); ## ## ## <#/GAPDoc> -DeclareAttribute( "Grp", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "Grp", IsRecogNode, "mutable" ); ## <#GAPDoc Label="Homom"> ## @@ -94,7 +94,7 @@ DeclareAttribute( "Grp", IsRecognitionInfo, "mutable" ); ## ## ## <#/GAPDoc> -DeclareAttribute( "Homom", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "Homom", IsRecogNode, "mutable" ); ## <#GAPDoc Label="NiceGens"> ## @@ -119,11 +119,11 @@ DeclareAttribute( "Homom", IsRecognitionInfo, "mutable" ); ## ## ## <#/GAPDoc> -DeclareAttribute( "NiceGens", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "NiceGens", IsRecogNode, "mutable" ); -## <#GAPDoc Label="RIFac"> +## <#GAPDoc Label="ImageRecogNode"> ## -## +## ## ## The value of this attribute is the recognition info record of the ## image of the homomorphism that was found from the group described by @@ -135,11 +135,11 @@ DeclareAttribute( "NiceGens", IsRecognitionInfo, "mutable" ); ## ## ## <#/GAPDoc> -DeclareAttribute( "RIFac", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "ImageRecogNode", IsRecogNode, "mutable" ); -## <#GAPDoc Label="RIKer"> +## <#GAPDoc Label="KernelRecogNode"> ## -## +## ## ## The value of this attribute is the recognition info record of the ## kernel of the homomorphism that was found from the group described by @@ -153,7 +153,7 @@ DeclareAttribute( "RIFac", IsRecognitionInfo, "mutable" ); ## ## ## <#/GAPDoc> -DeclareAttribute( "RIKer", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "KernelRecogNode", IsRecogNode, "mutable" ); ## <#GAPDoc Label="RIParent"> ## @@ -165,7 +165,7 @@ DeclareAttribute( "RIKer", IsRecognitionInfo, "mutable" ); ## ## ## <#/GAPDoc> -DeclareAttribute( "RIParent", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "RIParent", IsRecogNode, "mutable" ); ## <#GAPDoc Label="StdPresentation"> ## @@ -176,10 +176,10 @@ DeclareAttribute( "RIParent", IsRecognitionInfo, "mutable" ); ## ## ## <#/GAPDoc> -DeclareAttribute( "StdPresentation", IsRecognitionInfo, "mutable" ); # TODO: implement +DeclareAttribute( "StdPresentation", IsRecogNode, "mutable" ); # TODO: implement -DeclareProperty( "IsRecogInfoForSimpleGroup", IsRecognitionInfo ); -DeclareProperty( "IsRecogInfoForAlmostSimpleGroup", IsRecognitionInfo ); +DeclareProperty( "IsRecogInfoForSimpleGroup", IsRecogNode ); +DeclareProperty( "IsRecogInfoForAlmostSimpleGroup", IsRecogNode ); InstallTrueMethod( IsRecogInfoForAlmostSimpleGroup, IsRecogInfoForSimpleGroup ); ## <#GAPDoc Label="pregensfac"> @@ -195,8 +195,8 @@ InstallTrueMethod( IsRecogInfoForAlmostSimpleGroup, IsRecogInfoForSimpleGroup ); ## ## ## <#/GAPDoc> -DeclareAttribute( "pregensfac", IsRecognitionInfo, "mutable" ); -DeclareAttribute( "validatehomominput", IsRecognitionInfo); +DeclareAttribute( "pregensfac", IsRecogNode, "mutable" ); +DeclareAttribute( "validatehomominput", IsRecogNode); ## <#GAPDoc Label="calcnicegens"> ## @@ -220,7 +220,7 @@ DeclareAttribute( "validatehomominput", IsRecognitionInfo); ## ## ## <#/GAPDoc> -DeclareAttribute( "calcnicegens", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "calcnicegens", IsRecogNode, "mutable" ); ## <#GAPDoc Label="slptonice"> ## @@ -234,7 +234,7 @@ DeclareAttribute( "calcnicegens", IsRecognitionInfo, "mutable" ); ## ## ## <#/GAPDoc> -DeclareAttribute( "slptonice", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "slptonice", IsRecogNode, "mutable" ); ## <#GAPDoc Label="fhmethsel"> ## @@ -248,7 +248,7 @@ DeclareAttribute( "slptonice", IsRecognitionInfo, "mutable" ); ## ## ## <#/GAPDoc> -DeclareAttribute( "fhmethsel", IsRecognitionInfo, "mutable" ); # TODO: rename? +DeclareAttribute( "fhmethsel", IsRecogNode, "mutable" ); # TODO: rename? ## <#GAPDoc Label="methodsforfactor"> ## @@ -268,7 +268,7 @@ DeclareAttribute( "fhmethsel", IsRecognitionInfo, "mutable" ); # TODO: rena ## ## ## <#/GAPDoc> -DeclareAttribute( "methodsforfactor", IsRecognitionInfo, "mutable" ); # rename to MethodsDBForFactor +DeclareAttribute( "methodsforfactor", IsRecogNode, "mutable" ); # rename to MethodsDBForFactor ## <#GAPDoc Label="slpforelement"> ## @@ -291,28 +291,28 @@ DeclareAttribute( "methodsforfactor", IsRecognitionInfo, "mutable" ); # rename t ## ## ## <#/GAPDoc> -DeclareAttribute( "slpforelement", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "slpforelement", IsRecogNode, "mutable" ); # Here we collect generators of the kernel: -DeclareAttribute( "gensN", IsRecognitionInfo, "mutable" ); # TODO: rename? +DeclareAttribute( "gensN", IsRecogNode, "mutable" ); # TODO: rename? # The following holds a method, described by a record, to find generators # of the kernel: -DeclareAttribute( "findgensNmeth", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "findgensNmeth", IsRecogNode, "mutable" ); # Here is one slp to make all the gensN: -DeclareAttribute( "gensNslp", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "gensNslp", IsRecogNode, "mutable" ); # Do we have to do an immediate verification of the kernel? -DeclareAttribute( "immediateverification", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "immediateverification", IsRecogNode, "mutable" ); # Used to transport information about the group down to the kernel: -DeclareAttribute( "forkernel", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "forkernel", IsRecogNode, "mutable" ); # Used to transport information about the group down to the factor: -DeclareAttribute( "forfactor", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "forfactor", IsRecogNode, "mutable" ); # Used to check whether group elements are equal to one after recognition: -DeclareAttribute( "isone", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "isone", IsRecogNode, "mutable" ); # Used to compare group elements after recognition: -DeclareAttribute( "isequal", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "isequal", IsRecogNode, "mutable" ); # Used to compute order of group elements after recognition: -DeclareAttribute( "order", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "order", IsRecogNode, "mutable" ); # Used to check whether two group elements commute: -DeclareAttribute( "docommute", IsRecognitionInfo, "mutable" ); +DeclareAttribute( "docommute", IsRecogNode, "mutable" ); ############################################################################# @@ -657,13 +657,13 @@ DeclareGlobalFunction( "FastNormalClosure" ); DeclareGlobalFunction( "FindKernelFastNormalClosure" ); DeclareGlobalFunction( "FindKernelRandom" ); DeclareGlobalFunction( "FindKernelDoNothing" ); -DeclareOperation( "RandomElm", [ IsRecognitionInfo, IsString, IsBool ] ); -DeclareOperation( "RandomElmOrd", [ IsRecognitionInfo, IsString, IsBool ] ); -DeclareOperation( "RandomElmPpd", [ IsRecognitionInfo, IsString, IsBool ] ); -DeclareOperation( "RandomOrdersSeen", [ IsRecognitionInfo ] ); -DeclareOperation( "StopStoringRandEls", [ IsRecognitionInfo ] ); -DeclareOperation( "GetElmOrd", [ IsRecognitionInfo, IsRecord ] ); -DeclareOperation( "GetElmPpd", [ IsRecognitionInfo, IsRecord ] ); +DeclareOperation( "RandomElm", [ IsRecogNode, IsString, IsBool ] ); +DeclareOperation( "RandomElmOrd", [ IsRecogNode, IsString, IsBool ] ); +DeclareOperation( "RandomElmPpd", [ IsRecogNode, IsString, IsBool ] ); +DeclareOperation( "RandomOrdersSeen", [ IsRecogNode ] ); +DeclareOperation( "StopStoringRandEls", [ IsRecogNode ] ); +DeclareOperation( "GetElmOrd", [ IsRecogNode, IsRecord ] ); +DeclareOperation( "GetElmPpd", [ IsRecogNode, IsRecord ] ); # Finally the generic verification procedure: diff --git a/gap/base/recognition.gi b/gap/base/recognition.gi index 2ea37fcd2..f15c6cab7 100644 --- a/gap/base/recognition.gi +++ b/gap/base/recognition.gi @@ -57,17 +57,17 @@ RECOG_ViewObj := function( level, ri ) fi; if not IsLeaf(ri) then Print("\n",String("",level)," F:"); - if HasRIFac(ri) then - RECOG_ViewObj(level+3, RIFac(ri)); + if HasImageRecogNode(ri) then + RECOG_ViewObj(level+3, ImageRecogNode(ri)); else Print("has no factor"); fi; Print("\n",String("",level), " K:"); - if HasRIKer(ri) then - if RIKer(ri) = fail then + if HasKernelRecogNode(ri) then + if KernelRecogNode(ri) = fail then Print(""); end; -InstallMethod( ViewObj, "for recognition infos", [IsRecognitionInfo], +InstallMethod( ViewObj, "for recognition infos", [IsRecogNode], function(ri) RECOG_ViewObj(0, ri); end); @@ -230,7 +230,7 @@ end; # A method for PseudoRandom is installed such that it calls # RandomElm(ri, "PseudoRandom", false). InstallMethod( RandomElm, "for a recognition info record, a string and a bool", - [ IsRecognitionInfo, IsString, IsBool ], + [ IsRecogNode, IsString, IsBool ], function(ri, stamp, mem) local pos,el; if ri!.randstore then @@ -257,7 +257,7 @@ InstallMethod( RandomElm, "for a recognition info record, a string and a bool", # For an explanation see RandomElm. InstallMethod( RandomElmOrd, "for a recognition info record, a string and a bool", - [ IsRecognitionInfo, IsString, IsBool ], + [ IsRecogNode, IsString, IsBool ], function(ri, stamp, mem) local pos,res; if ri!.randstore then @@ -292,7 +292,7 @@ InstallMethod( RandomElmOrd, # If ri!.randstore is true this function tries to look up or computes and # stores the order in ri. InstallMethod( GetElmOrd, "for a recognition info record and a record", - [ IsRecognitionInfo, IsRecord ], + [ IsRecogNode, IsRecord ], function( ri, r ) local x; if ri!.randstore then @@ -311,7 +311,7 @@ InstallMethod( GetElmOrd, "for a recognition info record and a record", # FIXME: unused? # InstallMethod( RandomElmPpd, # "for a recognition info record, a string and a bool", -# [ IsRecognitionInfo, IsString, IsBool ], +# [ IsRecogNode, IsString, IsBool ], # function(ri, s, mem) # local pos,res; # if ri!.randstore then @@ -357,7 +357,7 @@ InstallMethod( GetElmOrd, "for a recognition info record and a record", # FIXME: unused? # InstallMethod( GetElmPpd, "for a recognition info record and a record", -# [ IsRecognitionInfo, IsRecord ], +# [ IsRecogNode, IsRecord ], # function( ri, r ) # local x; # if IsObjWithMemory(r.el) then @@ -389,14 +389,14 @@ InstallMethod( GetElmOrd, "for a recognition info record and a record", # end ); InstallMethod( RandomOrdersSeen, "for a recognition info record", - [ IsRecognitionInfo ], + [ IsRecogNode ], function(ri) return Compacted(ri!.rando); end ); # FIXME: unused? # InstallMethod( StopStoringRandEls, "for a recognition info record", -# [ IsRecognitionInfo ], +# [ IsRecogNode ], # function(ri) # ri!.randstore := false; # Unbind(ri!.randr); @@ -531,7 +531,7 @@ InstallGlobalFunction( RecogniseGeneric, methodsforfactor(ri), depthString, forfactor(ri) ); # TODO: change forfactor to hintsForFactor??) Remove(depthString); PrintTreePos("F",depthString,H); - SetRIFac(ri,rifac); + SetImageRecogNode(ri,rifac); SetRIParent(rifac,ri); if IsMatrixGroup(H) then @@ -584,7 +584,7 @@ InstallGlobalFunction( RecogniseGeneric, # We found out that N is the trivial group! # In this case we do nothing, kernel is fail indicating this. Info(InfoRecog,2,"Found trivial kernel (depth=",depth,")."); - SetRIKer(ri,fail); + SetKernelRecogNode(ri,fail); # We have to learn from the factor, what our nice generators are: SetNiceGens(ri,pregensfac(ri)); SetFilterObj(ri,IsReady); @@ -606,7 +606,7 @@ InstallGlobalFunction( RecogniseGeneric, riker := RecogniseGeneric( N, methoddb, depthString, forkernel(ri) ); Remove(depthString); PrintTreePos("K",depthString,H); - SetRIKer(ri,riker); + SetKernelRecogNode(ri,riker); SetRIParent(riker,ri); Info(InfoRecog,2,"Back from kernel (depth=",depth,")."); @@ -694,14 +694,14 @@ InstallGlobalFunction( CalcNiceGensHomNode, function(ri, origgens) local nicegens, kernelgens; # compute preimages of the nicegens of the factor group - nicegens := CalcNiceGens(RIFac(ri), origgens); + nicegens := CalcNiceGens(ImageRecogNode(ri), origgens); # Is there a non-trivial kernel? then add its nicegens - if HasRIKer(ri) and RIKer(ri) <> fail then - # we cannot just use gensN(RIKer(ri)) here, as those values are defined + if HasKernelRecogNode(ri) and KernelRecogNode(ri) <> fail then + # we cannot just use gensN(KernelRecogNode(ri)) here, as those values are defined # relative to the original generators we used during recognition; but # the origgens passed to this function might differ kernelgens := ResultOfStraightLineProgram(gensNslp(ri), origgens); - Append(nicegens, CalcNiceGens(RIKer(ri), kernelgens)); + Append(nicegens, CalcNiceGens(KernelRecogNode(ri), kernelgens)); fi; return nicegens; end ); @@ -720,8 +720,8 @@ InstallGlobalFunction( SLPforElementGeneric, # generic method for a non-leaf node function(ri,g) local gg,n,rifac,riker,s,s1,s2,y,nr1,nr2; - rifac := RIFac(ri); - riker := RIKer(ri); # note: might be fail + rifac := ImageRecogNode(ri); + riker := KernelRecogNode(ri); # note: might be fail if not ValidateHomomInput(ri, g) then return fail; @@ -765,7 +765,7 @@ InstallGlobalFunction( FindKernelRandom, local i,l,rifac,s,x,y; Info(InfoRecog,2,"Creating ",n," random generators for kernel."); l := gensN(ri); - rifac := RIFac(ri); + rifac := ImageRecogNode(ri); for i in [1..n] do x := RandomElm(ri,"KERNELANDVERIFY",true).el; Assert(2, ValidateHomomInput(ri, x)); @@ -868,7 +868,7 @@ InstallGlobalFunction( FindKernelFastNormalClosure, end); InstallOtherMethod( Size, "for a recognition info record", - [IsRecognitionInfo and IsReady], + [IsRecogNode and IsReady], function(ri) local size; if IsLeaf(ri) then @@ -876,9 +876,9 @@ InstallOtherMethod( Size, "for a recognition info record", # of the recognition info record! return Size(Grp(ri)); else - size := Size(RIFac(ri)); - if RIKer(ri) <> fail then - return Size(RIKer(ri)) * size; + size := Size(ImageRecogNode(ri)); + if KernelRecogNode(ri) <> fail then + return Size(KernelRecogNode(ri)) * size; else return size; # trivial kernel fi; @@ -886,13 +886,13 @@ InstallOtherMethod( Size, "for a recognition info record", end); InstallOtherMethod( Size, "for a failed recognition info record", - [IsRecognitionInfo], + [IsRecogNode], function(ri) ErrorNoReturn("the recognition described by this info record has failed!"); end); InstallOtherMethod( \in, "for a group element and a recognition info record", - [IsObject, IsRecognitionInfo and IsReady], + [IsObject, IsRecogNode and IsReady], function( el, ri ) local gens,slp; slp := SLPforElement(ri,el); @@ -908,7 +908,7 @@ InstallOtherMethod( \in, "for a group element and a recognition info record", end); InstallOtherMethod( \in, "for a group element and a recognition info record", - [IsObject, IsRecognitionInfo], + [IsObject, IsRecogNode], function( el, ri ) ErrorNoReturn("the recognition described by this info record has failed!"); end); @@ -944,12 +944,12 @@ InstallGlobalFunction( "DisplayCompositionFactors", function(arg) Print(IsomorphismTypeInfoFiniteSimpleGroup( f ).name, "\n" ); od; else - if HasRIKer(ri) and RIKer(ri) <> fail then - DisplayCompositionFactors(RIFac(ri),depth+1,homs+1, - ksize*Size(RIKer(ri))); - DisplayCompositionFactors(RIKer(ri),depth+1,homs,ksize); + if HasKernelRecogNode(ri) and KernelRecogNode(ri) <> fail then + DisplayCompositionFactors(ImageRecogNode(ri),depth+1,homs+1, + ksize*Size(KernelRecogNode(ri))); + DisplayCompositionFactors(KernelRecogNode(ri),depth+1,homs,ksize); else - DisplayCompositionFactors(RIFac(ri),depth+1,homs+1,ksize); + DisplayCompositionFactors(ImageRecogNode(ri),depth+1,homs+1,ksize); fi; fi; if depth = 0 then @@ -974,8 +974,8 @@ InstallGlobalFunction( "GetCompositionTreeNode", local r,c; r := ri; for c in what do - if c in "fF" then r := RIFac(r); - elif c in "kK" then r := RIKer(r); fi; + if c in "fF" then r := ImageRecogNode(r); + elif c in "kK" then r := KernelRecogNode(r); fi; od; return r; end ); @@ -1191,12 +1191,12 @@ RECOG.TestRecognitionNode := function(ri,stop,recurse) if IsLeaf(ri) then return rec(err := err, badnode := ri); fi; - ef := RECOG.TestRecognitionNode(RIFac(ri),stop,recurse); + ef := RECOG.TestRecognitionNode(ImageRecogNode(ri),stop,recurse); if IsRecord(ef) then return ef; fi; - if RIKer(ri) <> fail then - ek := RECOG.TestRecognitionNode(RIKer(ri),stop,recurse); + if KernelRecogNode(ri) <> fail then + ek := RECOG.TestRecognitionNode(KernelRecogNode(ri),stop,recurse); if IsRecord(ek) then return ek; fi; diff --git a/gap/generic/KnownNilpotent.gi b/gap/generic/KnownNilpotent.gi index 6bc0c6afa..7d41ae92b 100644 --- a/gap/generic/KnownNilpotent.gi +++ b/gap/generic/KnownNilpotent.gi @@ -66,8 +66,8 @@ RECOG.CalcNiceGensKnownNilpotent := function(ri,origgens) local kernelgens; kernelgens := List([1..Length(ri!.decompositionExponents)], i -> origgens[i]^ri!.decompositionExponents[i]); - return Concatenation(CalcNiceGens(RIFac(ri), origgens), - CalcNiceGens(RIKer(ri), kernelgens)); + return Concatenation(CalcNiceGens(ImageRecogNode(ri), origgens), + CalcNiceGens(KernelRecogNode(ri), kernelgens)); end; #! @BeginChunk KnownNilpotent diff --git a/gap/matrix.gi b/gap/matrix.gi index 477764fa2..10d6a4753 100644 --- a/gap/matrix.gi +++ b/gap/matrix.gi @@ -689,7 +689,7 @@ InstallGlobalFunction( FindKernelLowerLeftPGroup, nothingnew := 0; # we count until we produced 10 new generators # giving no new dimension - rifac := RIFac(ri); + rifac := ImageRecogNode(ri); while nothingnew < 10 do x := RandomElm(ri,"KERNEL",true).el; Assert(2, ValidateHomomInput(ri, x)); diff --git a/gap/projective/d247.gi b/gap/projective/d247.gi index 001b14fa7..c06a53b3d 100644 --- a/gap/projective/d247.gi +++ b/gap/projective/d247.gi @@ -287,9 +287,9 @@ ConvertToMatrixRep(homcomp,Size(f)); # gap> gens:=List(GeneratorsOfGroup(G),g->PermutationMat(g,n)) * Z(5);; # gap> gens[1][1][2] := -gens[1][1][2];; gens[2][7][5] := -gens[2][7][5];; # gap> H2:=Group(gens);; ri:=RecognizeGroup( H2 ); - # gap> Grp(RIFac(ri)); + # gap> Grp(ImageRecogNode(ri)); # - # gap> Grp(RIFac(RIFac(ri))); + # gap> Grp(ImageRecogNode(ImageRecogNode(ri))); # Group([ (1,2,3,4,5,6,7), (1,2,3) ]) a := OrbActionHomomorphism(G,o); diff --git a/misc/colva/Evaluate.g b/misc/colva/Evaluate.g index fede91450..3501e35a6 100644 --- a/misc/colva/Evaluate.g +++ b/misc/colva/Evaluate.g @@ -229,7 +229,7 @@ InstallGlobalFunction( NormalTree, rifac := RecogniseLeaf(ri,I,name);; - SetRIFac(ri,rifac); + SetImageRecogNode(ri,rifac); SetRIParent(rifac,ri); Info(InfoRecognition,1,"Back from factor (depth=",depth,")."); @@ -279,7 +279,7 @@ InstallGlobalFunction( NormalTree, # We found out that N is the trivial group! # In this case we do nothing, kernel is fail indicating this. Info(InfoRecognition,1,"Found trivial kernel (depth=",depth,")."); - SetRIKer(ri,fail); + SetKernelRecogNode(ri,fail); # We have to learn from the factor, what our nice generators are: SetNiceGens(ri,pregensfac(ri)); SetFilterObj(ri,IsReady); @@ -294,7 +294,7 @@ InstallGlobalFunction( NormalTree, N := Group(StripMemory(gensN(ri))); riker := NormalTree( N, nsm, depth+1 );; - SetRIKer(ri,riker); + SetKernelRecogNode(ri,riker); SetRIParent(riker,ri); Info(InfoRecognition,1,"Back from kernel (depth=",depth,")."); diff --git a/misc/colva/Rearrange.g b/misc/colva/Rearrange.g index 53e6c577b..1e0149b26 100644 --- a/misc/colva/Rearrange.g +++ b/misc/colva/Rearrange.g @@ -102,51 +102,51 @@ PastNonAb := function(ri) x := pregensfac(ri)[1]; - if IsDirectProduct(Grp(RIFac(RIKer(ri)))) and not IsTrivial(PermAction(GroupWithGenerators([x]),Grp(RIKer(ri)),Homom(RIKer(ri)),Grp(RIFac(RIKer(ri))))) then return false; + if IsDirectProduct(Grp(ImageRecogNode(KernelRecogNode(ri)))) and not IsTrivial(PermAction(GroupWithGenerators([x]),Grp(KernelRecogNode(ri)),Homom(KernelRecogNode(ri)),Grp(ImageRecogNode(KernelRecogNode(ri))))) then return false; fi; - riker := RIKer(ri); -# Consider the automorphism of RIFac(riker) induced by x - aut := GroupHomomorphismByFunction(Grp(RIFac(riker)),Grp(RIFac(riker)), + riker := KernelRecogNode(ri); +# Consider the automorphism of ImageRecogNode(riker) induced by x + aut := GroupHomomorphismByFunction(Grp(ImageRecogNode(riker)),Grp(ImageRecogNode(riker)), function(g) local w,preim; - w := slpforelement(RIFac(riker))(RIFac(riker),g); + w := slpforelement(ImageRecogNode(riker))(ImageRecogNode(riker),g); preim := ResultOfStraightLineProgram(w,pregensfac(riker)); return ImageElm(Homom(riker),preim^x); end); # Is aut inner? - tell it that it's an automorphism. SetIsBijective(aut, true); - t := MyIsInnerAutomorphism(Grp(RIFac(riker)),Name(RIFac(riker)),aut,g->slpforelement(RIFac(riker))(RIFac(riker),g)); + t := MyIsInnerAutomorphism(Grp(ImageRecogNode(riker)),Name(ImageRecogNode(riker)),aut,g->slpforelement(ImageRecogNode(riker))(ImageRecogNode(riker),g)); if t=false then return false; fi; # Check that all automorphisms induced by prefacgens induce inner auto's inns := [t]; for i in [2..Length(pregensfac(ri))] do x := pregensfac(ri)[i]; - aut := GroupHomomorphismByFunction(Grp(RIFac(riker)),Grp(RIFac(riker)), + aut := GroupHomomorphismByFunction(Grp(ImageRecogNode(riker)),Grp(ImageRecogNode(riker)), function(g) local w,preim; - w := slpforelement(RIFac(riker))(RIFac(riker),g); + w := slpforelement(ImageRecogNode(riker))(ImageRecogNode(riker),g); preim := ResultOfStraightLineProgram(w,pregensfac(riker)); return ImageElm(Homom(riker),preim^x); end); - conj_elt:= MyIsInnerAutomorphism(Grp(RIFac(riker)),Name(RIFac(riker)),aut,g->slpforelement(RIFac(riker))(RIFac(riker),g)); + conj_elt:= MyIsInnerAutomorphism(Grp(ImageRecogNode(riker)),Name(ImageRecogNode(riker)),aut,g->slpforelement(ImageRecogNode(riker))(ImageRecogNode(riker),g)); if conj_elt = false then return false; fi; Add(inns, conj_elt); od; - innspreims := List(inns, t->ResultOfStraightLineProgram(slpforelement(RIFac(riker))(RIFac(riker),t),pregensfac(riker))); + innspreims := List(inns, t->ResultOfStraightLineProgram(slpforelement(ImageRecogNode(riker))(ImageRecogNode(riker),t),pregensfac(riker))); # Construct a lifting into the centraliser y := List([1..Length(innspreims)],i->pregensfac(ri)[i]*innspreims[i]^-1); # Define a lifting - - l := x->ResultOfStraightLineProgram(slpforelement(RIFac(ri))(RIFac(ri),x),y); + l := x->ResultOfStraightLineProgram(slpforelement(ImageRecogNode(ri))(ImageRecogNode(ri),x),y); rihom := StructuralCopy(Homom(ri)); kerhom := StructuralCopy(Homom(riker)); - zeta := GroupHomomorphismByFunction(Grp(ri),Grp(RIFac(riker)),function(g) + zeta := GroupHomomorphismByFunction(Grp(ri),Grp(ImageRecogNode(riker)),function(g) local g1; g1 := l(ImageElm(rihom,g)); return ImageElm(kerhom,g*g1^-1); @@ -155,29 +155,29 @@ end); return zeta; end; -#returns a function from Grp(ri) to Grp(RIFac(RIKer(ri))) if can do so, +#returns a function from Grp(ri) to Grp(ImageRecogNode(KernelRecogNode(ri))) if can do so, #otherwise returns false. AbPastAb := function(ri) ## Tries to push an abelian layer past another abelian layer where the layers are over different primes local x,riker,i,im,q,l,zeta; x := pregensfac(ri)[1]; - riker := RIKer(ri);; -# Does x act trivially on RIFac(riker) - for i in [1..Length(NiceGens(RIFac(riker)))] do + riker := KernelRecogNode(ri);; +# Does x act trivially on ImageRecogNode(riker) + for i in [1..Length(NiceGens(ImageRecogNode(riker)))] do im := ImageElm(Homom(riker),pregensfac(riker)[i]^x); - if im <> NiceGens(RIFac(riker))[i] then + if im <> NiceGens(ImageRecogNode(riker))[i] then return false; fi; od; -# Now we know x acts trivially on RIFac(riker) +# Now we know x acts trivially on ImageRecogNode(riker) # Construct the new lifting - q := Grp(RIFac(riker))!.Pcgs!.RelativeOrders[1]; - l := GroupHomomorphismByImagesNC(Grp(RIFac(ri)),Grp(ri),List(NiceGens(RIFac(ri)),x->x^q),List(pregensfac(ri),x->x^q)); + q := Grp(ImageRecogNode(riker))!.Pcgs!.RelativeOrders[1]; + l := GroupHomomorphismByImagesNC(Grp(ImageRecogNode(ri)),Grp(ri),List(NiceGens(ImageRecogNode(ri)),x->x^q),List(pregensfac(ri),x->x^q)); # Construct the new map - zeta := GroupHomomorphismByFunction(Grp(ri),Grp(RIFac(riker)),g->ImageElm(Homom(riker),g*ImageElm(Homom(ri)*l,g)^-1)); + zeta := GroupHomomorphismByFunction(Grp(ri),Grp(ImageRecogNode(riker)),g->ImageElm(Homom(riker),g*ImageElm(Homom(ri)*l,g)^-1)); return zeta; end; @@ -188,29 +188,29 @@ AbPastAbSamePrime := function(ri) g,M,CS,maps,zeta,k,AcGens,L,intorikerfac; x := pregensfac(ri)[1]; - riker := RIKer(ri);; + riker := KernelRecogNode(ri);; if not SanityCheck(ri) then Error(179); fi; -# Does x act trivially on RIFac(riker) - for i in [1..Length(NiceGens(RIFac(riker)))] do +# Does x act trivially on ImageRecogNode(riker) + for i in [1..Length(NiceGens(ImageRecogNode(riker)))] do im := ImageElm(Homom(riker),pregensfac(riker)[i]^x); - if im <> NiceGens(RIFac(riker))[i] then + if im <> NiceGens(ImageRecogNode(riker))[i] then return [false]; fi; od; # Construct a map down onto the direct product of the two factor groups - p := Grp(RIFac(riker))!.Pcgs!.RelativeOrders[1]; - l := GroupHomomorphismByImagesNC(Grp(RIFac(ri)),Grp(ri),NiceGens(RIFac(ri)),pregensfac(ri)); - psi := GroupHomomorphismByFunction(Grp(ri),Grp(RIFac(riker)),g->ImageElm(Homom(riker),g*ImageElm(l,ImageElm(Homom(ri),g))^-1)); + p := Grp(ImageRecogNode(riker))!.Pcgs!.RelativeOrders[1]; + l := GroupHomomorphismByImagesNC(Grp(ImageRecogNode(ri)),Grp(ri),NiceGens(ImageRecogNode(ri)),pregensfac(ri)); + psi := GroupHomomorphismByFunction(Grp(ri),Grp(ImageRecogNode(riker)),g->ImageElm(Homom(riker),g*ImageElm(l,ImageElm(Homom(ri),g))^-1)); # check generators and relations of facto(ri) map to 1 under psi checkelts1 := List(pregensfac(ri),x->x^p); if not ForAll(checkelts1,x->IsOne(ImageElm(psi,x))) then return [false]; fi; checkelts2 := Concatenation(List([1..Length(pregensfac(ri))],i->List([(i+1)..Length(pregensfac(ri))],j->Comm(pregensfac(ri)[i],pregensfac(ri)[j])))); if not ForAll(checkelts2,x->IsOne(ImageElm(psi,x))) then return [false]; fi; - D := DirectProduct(Grp(RIFac(ri)),Grp(RIFac(riker))); + D := DirectProduct(Grp(ImageRecogNode(ri)),Grp(ImageRecogNode(riker))); phi := GroupHomomorphismByFunction(Grp(ri),D,g->ImageElm(Homom(ri)*Embedding(D,1),g)*ImageElm(psi*Embedding(D,2),g)); pregens := Concatenation(pregensfac(ri),pregensfac(riker)); # Construct the action of G on D @@ -233,10 +233,10 @@ SubgroupNC(D,List(x,v->VectortoPc(v,D)))); maps := List(L,x->NaturalHomomorphismByNormalSubgroupNC(D,x)); - intorikerfac := List(maps,x->IsomorphismGroups(Range(x),Grp(RIFac(riker)))); + intorikerfac := List(maps,x->IsomorphismGroups(Range(x),Grp(ImageRecogNode(riker)))); - zeta := List([1..Length(L)],i->GroupHomomorphismByFunction(Grp(ri),Grp(RIFac(riker)),g->ImageElm(intorikerfac[i],ImageElm(maps[i],ImageElm(phi,g))))); + zeta := List([1..Length(L)],i->GroupHomomorphismByFunction(Grp(ri),Grp(ImageRecogNode(riker)),g->ImageElm(intorikerfac[i],ImageElm(maps[i],ImageElm(phi,g))))); return zeta; end; @@ -246,26 +246,26 @@ NonAbPastAb := function(ri) local x,riker,i,target_size,s,im,gens,g,p,words,invims,invims1,gens2, zeta,h,lift,g1; - if not IsPermGroup(Grp(RIFac(ri))) then return false; fi; + if not IsPermGroup(Grp(ImageRecogNode(ri))) then return false; fi; x := pregensfac(ri)[1]; - riker := RIKer(ri);; -# Does x act trivially on RIFac(riker) - for i in [1..Length(NiceGens(RIFac(riker)))] do + riker := KernelRecogNode(ri);; +# Does x act trivially on ImageRecogNode(riker) + for i in [1..Length(NiceGens(ImageRecogNode(riker)))] do im := ImageElm(Homom(riker),pregensfac(riker)[i]^x); - if im <> NiceGens(RIFac(riker))[i] then + if im <> NiceGens(ImageRecogNode(riker))[i] then return false; fi; od; # construct a new generating set of elts coprime to p - p := Grp(RIFac(riker))!.Pcgs!.RelativeOrders[1]; - target_size:= Size(RIFac(ri)); + p := Grp(ImageRecogNode(riker))!.Pcgs!.RelativeOrders[1]; + target_size:= Size(ImageRecogNode(ri)); gens := []; #first see if just 4 generators will suffice for i in [1..4] do repeat - g := PseudoRandom(Grp(RIFac(ri))); + g := PseudoRandom(Grp(ImageRecogNode(ri))); g := g^(p^Valuation(Order(g),p)); until not IsOne(g); Add(gens,g); @@ -277,7 +277,7 @@ NonAbPastAb := function(ri) #one-by-one and check each time. while SizeStabChain(s) < target_size do repeat - g := PseudoRandom(Grp(RIFac(ri))); + g := PseudoRandom(Grp(ImageRecogNode(ri))); g := g^(p^Valuation(Order(g),p)); until not IsOne(g); Add(gens, g); @@ -286,26 +286,26 @@ NonAbPastAb := function(ri) od; #all of these were PseudoRandom(Grp(ri)) but since that's a matrix - #group i presume should be conjugating in RIFac(ri) - Colva. - #Add(gens,g^PseudoRandom(Grp(RIFac(ri)))); - #Add(gens,g^PseudoRandom(Grp(RIFac(ri)))); - #Add(gens,g^PseudoRandom(Grp(RIFac(ri)))); + #group i presume should be conjugating in ImageRecogNode(ri) - Colva. + #Add(gens,g^PseudoRandom(Grp(ImageRecogNode(ri)))); + #Add(gens,g^PseudoRandom(Grp(ImageRecogNode(ri)))); + #Add(gens,g^PseudoRandom(Grp(ImageRecogNode(ri)))); #repeat - # g := PseudoRandom(Grp(RIFac(ri))); + # g := PseudoRandom(Grp(ImageRecogNode(ri))); # g := g^(p^Valuation(Order(g),p)); #until not IsOne(g); #Add(gens,g); - #Add(gens,g^PseudoRandom(Grp(RIFac(ri)))); - #Add(gens,g^PseudoRandom(Grp(RIFac(ri)))); - #Add(gens,g^PseudoRandom(Grp(RIFac(ri)))); + #Add(gens,g^PseudoRandom(Grp(ImageRecogNode(ri)))); + #Add(gens,g^PseudoRandom(Grp(ImageRecogNode(ri)))); + #Add(gens,g^PseudoRandom(Grp(ImageRecogNode(ri)))); - words := List(gens,x->SLPforElement(RIFac(ri),x)); + words := List(gens,x->SLPforElement(ImageRecogNode(ri),x)); invims1 := List(words,w->ResultOfStraightLineProgram(w,pregensfac(ri))); invims := List(invims1,x->x^(p^Valuation(Order(x),p))); #should this be invims1 or invims in next line??? gens2 := List(invims, x->ImageElm(Homom(ri),x)); - lift := GroupHomomorphismByImagesNC(Grp(RIFac(ri)),Grp(ri),gens2,invims); - zeta := GroupHomomorphismByFunction(Grp(ri),Grp(RIFac(riker)),g->ImageElm(Homom(riker),g*ImageElm(lift, ImageElm(Homom(ri),g))^-1)); + lift := GroupHomomorphismByImagesNC(Grp(ImageRecogNode(ri)),Grp(ri),gens2,invims); + zeta := GroupHomomorphismByFunction(Grp(ri),Grp(ImageRecogNode(riker)),g->ImageElm(Homom(riker),g*ImageElm(lift, ImageElm(Homom(ri),g))^-1)); # Do some random testing of elts to check that zeta is a hom @@ -326,9 +326,9 @@ PushIntoSocle := function(ri,zeta) local riker,D,phi,im1,im2,nri,nrifac,list,g,overgp; - riker := RIKer(ri);; + riker := KernelRecogNode(ri);; # Form the direct product of the socle - D := DirectProduct(Grp(RIFac(ri)),Grp(RIFac(riker))); + D := DirectProduct(Grp(ImageRecogNode(ri)),Grp(ImageRecogNode(riker))); # and the new map phi from Grp(ri) -> D phi := GroupHomomorphismByFunction(Grp(ri),D,function(g) local im1,im2; @@ -340,7 +340,7 @@ end); overgp := ShallowCopy(overgroup(ri)); -# setup the new record for the factor - this is the product of RIFac(ri) and RIFac(riker) +# setup the new record for the factor - this is the product of ImageRecogNode(ri) and ImageRecogNode(riker) nrifac := rec(); Objectify( RecognitionInfoType, nrifac );; @@ -348,39 +348,39 @@ end); SetGrp(nrifac,D); #map the NiceGens for each factor into the direct product, and take both sets of NiceGens. - SetNiceGens(nrifac,Concatenation(List(NiceGens(RIFac(ri)),x->ImageElm(MyEmbedding(D,1),x)),List(NiceGens(RIFac(riker)),x->ImageElm(MyEmbedding(D,2),x)))); + SetNiceGens(nrifac,Concatenation(List(NiceGens(ImageRecogNode(ri)),x->ImageElm(MyEmbedding(D,1),x)),List(NiceGens(ImageRecogNode(riker)),x->ImageElm(MyEmbedding(D,2),x)))); SetFilterObj(nrifac,IsLeaf); Setfhmethsel(nrifac,"socle"); Setslpforelement(nrifac, function(nrifac,g) local list; - list := [SLPforElement(RIFac(ri),ImageElm(MyProjection(D,1),g)),SLPforElement(RIFac(riker),ImageElm(MyProjection(D,2),g))]; + list := [SLPforElement(ImageRecogNode(ri),ImageElm(MyProjection(D,1),g)),SLPforElement(ImageRecogNode(riker),ImageElm(MyProjection(D,2),g))]; if fail in list then return fail; fi; return MyDirectProductOfSLPsList(list); end ); - SetSize(nrifac,Size(RIFac(ri))*Size(RIFac(riker))); + SetSize(nrifac,Size(ImageRecogNode(ri))*Size(ImageRecogNode(riker))); SetFilterObj(nrifac,IsReady); # setup the new record for the subgroup - nri will take the place of the old ri, but iwth #ker(riker) as its kernel and nrifac, the new socle, as its factor. nri := rec(); Objectify( RecognitionInfoType, nri );; - SetRIFac(nri,nrifac); + SetImageRecogNode(nri,nrifac); SetGrp(nri,Grp(ri)); if HasRIParent(ri) then SetRIParent(nri,RIParent(ri)); - SetRIKer(RIParent(nri),nri); + SetKernelRecogNode(RIParent(nri),nri); if not SanityCheck(RIParent(nri)) then Error(1); fi; fi; - if HasRIKer(riker) and RIKer(riker) = fail then - SetRIKer(nri, fail); - elif HasRIKer(riker) then - SetRIKer(nri,RIKer(riker)); - SetRIParent(RIKer(nri),nri); + if HasKernelRecogNode(riker) and KernelRecogNode(riker) = fail then + SetKernelRecogNode(nri, fail); + elif HasKernelRecogNode(riker) then + SetKernelRecogNode(nri,KernelRecogNode(riker)); + SetRIParent(KernelRecogNode(nri),nri); if not SanityCheck(nri) then Error(2); fi; @@ -389,17 +389,17 @@ end); ## Construct the preimages Setpregensfac(nri,Concatenation( List(pregensfac(ri),g-> -g*ResultOfStraightLineProgram(SLPforElement(RIFac(riker),ImageElm(phi*MyProjection(D,2),g)),pregensfac(riker))^-1), +g*ResultOfStraightLineProgram(SLPforElement(ImageRecogNode(riker),ImageElm(phi*MyProjection(D,2),g)),pregensfac(riker))^-1), pregensfac(riker))); #this was causing problems with the kernel was fail. - if HasRIKer(nri) and RIKer(nri) <> fail then - SetNiceGens(nri,Concatenation(pregensfac(nri),NiceGens(RIKer(nri)))); - elif HasRIKer(nri) then + if HasKernelRecogNode(nri) and KernelRecogNode(nri) <> fail then + SetNiceGens(nri,Concatenation(pregensfac(nri),NiceGens(KernelRecogNode(nri)))); + elif HasKernelRecogNode(nri) then #so the kernel is the trivial group, just need preimages of the socle generators. SetNiceGens(nri, pregensfac(nri)); fi; Setcalcnicegens(nri,CalcNiceGensHomNode); - SetName(nrifac,Concatenation(Name(RIFac(ri)),",",Name(RIFac(riker)))); + SetName(nrifac,Concatenation(Name(ImageRecogNode(ri)),",",Name(ImageRecogNode(riker)))); Setslpforelement(nri,SLPforElementGeneric); Setovergroup(nri,overgp); SetFilterObj(nri,IsReady); @@ -414,14 +414,14 @@ end; #into the socle. SwapFactors := function(ri,zeta) # Swaps the layers of the tree at ri using the map -# zeta : Grp(ri) -> Grp(RIFac(RIKer(ri))) +# zeta : Grp(ri) -> Grp(ImageRecogNode(KernelRecogNode(ri))) local riker,rifac,rikerfac,nri,nriker,overgp; - riker := RIKer(ri);; - rifac := RIFac(ri);; - rikerfac := RIFac(riker);; + riker := KernelRecogNode(ri);; + rifac := ImageRecogNode(ri);; + rikerfac := ImageRecogNode(riker);; # setup the new record for the factor nri := rec(); @@ -433,35 +433,35 @@ SwapFactors := function(ri,zeta) SetHomom(nri,zeta); Setpregensfac(nri,StructuralCopy(pregensfac(riker))); Setpregensfac(nriker,List(pregensfac(ri),x->x*ResultOfStraightLineProgram(SLPforElement(rikerfac,ImageElm(zeta,x)),pregensfac(riker))^-1)); - SetRIKer(nriker,StructuralCopy(RIKer(riker))); - SetRIParent(RIKer(nriker),nriker); + SetKernelRecogNode(nriker,StructuralCopy(KernelRecogNode(riker))); + SetRIParent(KernelRecogNode(nriker),nriker); SetRIParent(nriker,nri); - SetRIKer(nri, nriker); + SetKernelRecogNode(nri, nriker); if not SanityCheck(nri) then Error(3); fi; - SetRIFac(nriker,StructuralCopy(RIFac(ri))); + SetImageRecogNode(nriker,StructuralCopy(ImageRecogNode(ri))); #next two lines had capital p for parent before. #if IsBound(ri!.RIParent) then not sure whether should be checking HasRIParent, try that instead. if HasRIParent(ri) then SetRIParent(nri,StructuralCopy(RIParent(ri))); - SetRIKer(RIParent(nri),nri); + SetKernelRecogNode(RIParent(nri),nri); if not SanityCheck(RIParent(nri)) then Error(4); fi; fi; - if HasRIKer(riker) then - SetRIKer(nriker,RIKer(riker)); - SetRIParent(RIKer(riker),nriker); + if HasKernelRecogNode(riker) then + SetKernelRecogNode(nriker,KernelRecogNode(riker)); + SetRIParent(KernelRecogNode(riker),nriker); if not SanityCheck(nri) then Error(5); fi; fi; - SetRIFac(nri,StructuralCopy(RIFac(riker))); + SetImageRecogNode(nri,StructuralCopy(ImageRecogNode(riker))); #value of NiceGens is either the ones of the image on their own if kernel #is trivial, or gens for image plus gens for kernel. - if HasRIKer(nriker) and not (RIKer(nriker) = fail) then - SetNiceGens(nriker,Concatenation(pregensfac(nriker),NiceGens(RIKer(nriker)))); + if HasKernelRecogNode(nriker) and not (KernelRecogNode(nriker) = fail) then + SetNiceGens(nriker,Concatenation(pregensfac(nriker),NiceGens(KernelRecogNode(nriker)))); else SetNiceGens(nriker, pregensfac(nriker)); fi; @@ -470,9 +470,9 @@ SwapFactors := function(ri,zeta) Setcalcnicegens(nriker,CalcNiceGensHomNode); SetGrp(nri,StructuralCopy(Grp(ri))); #the group of nriker is the generators of the group of its kernel(if nontrivial) plus the preimages of the factor. - if HasRIKer(nriker) and not RIKer(nriker) = fail then - SetGrp(nriker,GroupWithGenerators(Concatenation(GeneratorsOfGroup(Grp(RIKer(nriker))),pregensfac(nriker)))); - elif HasRIKer(nriker) then + if HasKernelRecogNode(nriker) and not KernelRecogNode(nriker) = fail then + SetGrp(nriker,GroupWithGenerators(Concatenation(GeneratorsOfGroup(Grp(KernelRecogNode(nriker))),pregensfac(nriker)))); + elif HasKernelRecogNode(nriker) then SetGrp(nriker,GroupWithGenerators(pregensfac(nriker))); fi; Setslpforelement(nri,SLPforElementGeneric); @@ -492,8 +492,8 @@ end; #this checks that every factor group in the chief tree is polycyclic, if #so then group is soluble. IsSolubleTree := function(ri) - if not IsBound(Grp(RIFac(ri))!.Pcgs) then return false; fi; - if ri!.RIKer <> fail then return IsSolubleTree(RIKer(ri)); + if not IsBound(Grp(ImageRecogNode(ri))!.Pcgs) then return false; fi; + if ri!.KernelRecogNode <> fail then return IsSolubleTree(KernelRecogNode(ri)); else return true; fi; @@ -507,9 +507,9 @@ end; PushDown := function(pri) local priker,prifac,prikerfac,zeta,i,npri,nnpri,knpri; - priker := RIKer(pri); - prifac := RIFac(pri); - prikerfac := RIFac(priker); + priker := KernelRecogNode(pri); + prifac := ImageRecogNode(pri); + prikerfac := ImageRecogNode(priker); # Compute the push down maps - they depend on which groups are abelian. @@ -540,14 +540,14 @@ PushDown := function(pri) return false; fi; -# Is RIFac(priker)) the socle, i.e. are we pushing down into or +# Is ImageRecogNode(priker)) the socle, i.e. are we pushing down into or #past the socle? if IsBound(prikerfac!.TFordered) and prikerfac!.TFordered="Socle" then zeta := zeta[1]; #if both groups are insoluble then they should both be in the socle together. if not IsBound(Grp(prifac)!.Pcgs) then npri := PushIntoSocle(pri,zeta);; - SetTFordered(RIFac(npri),"Socle"); + SetTFordered(ImageRecogNode(npri),"Socle"); else #otherwise we should put prifac below prikerfac. npri := SwapFactors(pri,zeta);; @@ -559,7 +559,7 @@ PushDown := function(pri) return npri; fi; -#this is the case where RIFac(priker) is not the socle, we try +#this is the case where ImageRecogNode(priker) is not the socle, we try #each of our maps in turn and #look to see whether we can push pri down a level, then recurse to #try to push it down further. @@ -569,11 +569,11 @@ PushDown := function(pri) for i in [1..Length(zeta)] do Print("trying zeta, i is", i, "\n"); npri := SwapFactors(StructuralCopy(pri),zeta[i]);; - knpri := PushDown(StructuralCopy(RIKer(npri)));; + knpri := PushDown(StructuralCopy(KernelRecogNode(npri)));; #having a problem with something believing it's got a parent when it doesn't. if knpri <> false and npri <> false then #found a map that works. - SetRIKer(npri,knpri); + SetKernelRecogNode(npri,knpri); SetRIParent(knpri,npri); if not SanityCheck(npri) then Error(6); @@ -600,16 +600,16 @@ OrderTree := function(ri) # Is the tree soluble? in that case all is O_{\infty}(G) already. if IsSolubleTree(ri) then return ri; fi; # Is G simple? - if ((not HasRIKer(ri)) or (RIKer(ri) = fail)) then return ri; fi; + if ((not HasKernelRecogNode(ri)) or (KernelRecogNode(ri) = fail)) then return ri; fi; # Find the last non-abelian chief factor. lastnonabri := StructuralCopy(ri); - while RIKer(lastnonabri) <> fail and not IsSolubleTree(RIKer(lastnonabri)) do - lastnonabri := RIKer(lastnonabri); + while KernelRecogNode(lastnonabri) <> fail and not IsSolubleTree(KernelRecogNode(lastnonabri)) do + lastnonabri := KernelRecogNode(lastnonabri); od; # Tell that chief factor that it will be where the socle collects. - SetTFordered(RIFac(lastnonabri),"Socle"); + SetTFordered(ImageRecogNode(lastnonabri),"Socle"); # Go to socle layer. @@ -618,7 +618,7 @@ OrderTree := function(ri) # Push the soluble layers down while HasRIParent(pri) do pri := StructuralCopy(RIParent(pri)); - SetNiceGens(pri,Concatenation(pregensfac(pri),NiceGens(RIKer(pri)))); + SetNiceGens(pri,Concatenation(pregensfac(pri),NiceGens(KernelRecogNode(pri)))); npri := PushDown(StructuralCopy(pri));; if npri <> false then pri := StructuralCopy(npri); @@ -630,10 +630,10 @@ OrderTree := function(ri) #this is kind of messy, but i haven't managed to track down where all the #parent kernel factor not matching up errors are occurring - while HasRIKer(pri) and not RIKer(pri) = fail do - SetRIParent(RIKer(pri), pri); - SetRIParent(RIFac(pri), pri); - pri:= RIKer(pri); + while HasKernelRecogNode(pri) and not KernelRecogNode(pri) = fail do + SetRIParent(KernelRecogNode(pri), pri); + SetRIParent(ImageRecogNode(pri), pri); + pri:= KernelRecogNode(pri); od; while HasRIParent(pri) do pri:= RIParent(pri); diff --git a/misc/colva/Refine.g b/misc/colva/Refine.g index 72ebcccac..605f2a43b 100644 --- a/misc/colva/Refine.g +++ b/misc/colva/Refine.g @@ -14,7 +14,7 @@ InsertSubTree := function(ri,rifac,maps) local kerfac,phi,Q,GtoQ,lri,rri,ripregensfac,overgp,i,kgens; # remember the kernel of ri! - kerfac := RIKer(ri);; + kerfac := KernelRecogNode(ri);; # construct maps from ri -> new groups phi := StructuralCopy(Homom(ri)); @@ -68,8 +68,8 @@ InsertSubTree := function(ri,rifac,maps) lri[i+1] := rec(); Objectify(RecognitionInfoType,lri[i+1]);; SetGrp(lri[i+1],GroupWithGenerators(kgens)); - SetRIKer(lri[i],lri[i+1]); - SetRIFac(lri[i],rri[i]); + SetKernelRecogNode(lri[i],lri[i+1]); + SetImageRecogNode(lri[i],rri[i]); SetRIParent(lri[i+1],lri[i]); SetRIParent(rri[i],lri[i]); od; @@ -81,15 +81,15 @@ InsertSubTree := function(ri,rifac,maps) fi; # tell last lri to be kerfac - SetRIKer(lri[Size(Q)],StructuralCopy(kerfac)); - SetRIParent(RIKer(lri[Size(Q)]),lri[Size(Q)]); + SetKernelRecogNode(lri[Size(Q)],StructuralCopy(kerfac)); + SetRIParent(KernelRecogNode(lri[Size(Q)]),lri[Size(Q)]); # Set up the nice generators i := Size(Q); while i>0 do - if RIKer(lri[i]) <> fail then - SetNiceGens(lri[i],Concatenation(pregensfac(lri[i]),NiceGens(RIKer(lri[i])))); + if KernelRecogNode(lri[i]) <> fail then + SetNiceGens(lri[i],Concatenation(pregensfac(lri[i]),NiceGens(KernelRecogNode(lri[i])))); else SetNiceGens(lri[i],pregensfac(lri[i])); fi; @@ -105,15 +105,15 @@ RefineSolubleLayers := function(ri) if ri=fail then return ri; fi; - rifac := RIFac(ri);; + rifac := ImageRecogNode(ri);; phi := Homom(ri); I := Grp(rifac); if not IsPcGroup(I) or IsElementaryAbelian(I) then - riker := RIKer(ri); - SetRIKer(ri,RefineSolubleLayers(riker)); - if RIKer(ri)<>fail then - SetNiceGens(ri,Concatenation(pregensfac(ri),NiceGens(RIKer(ri)))); + riker := KernelRecogNode(ri); + SetKernelRecogNode(ri,RefineSolubleLayers(riker)); + if KernelRecogNode(ri)<>fail then + SetNiceGens(ri,Concatenation(pregensfac(ri),NiceGens(KernelRecogNode(ri)))); else SetNiceGens(ri,pregensfac(ri)); fi; @@ -123,11 +123,11 @@ RefineSolubleLayers := function(ri) L := InvariantElementaryAbelianSeries(I,GeneratorsOfGroup(AutomorphismGroup(I)) : fine := true); maps := List([1..Length(L)-1],i->NaturalHomomorphismByNormalSubgroupNC(L[i],L[i+1])); ri := InsertSubTree(ri, rifac, maps);; - riker := RIKer(ri); - SetRIKer(ri,RefineSolubleLayers(riker)); - SetRIParent(RIKer(ri),ri); - if RIKer(ri)<>fail then - SetNiceGens(ri,Concatenation(pregensfac(ri),NiceGens(RIKer(ri)))); + riker := KernelRecogNode(ri); + SetKernelRecogNode(ri,RefineSolubleLayers(riker)); + SetRIParent(KernelRecogNode(ri),ri); + if KernelRecogNode(ri)<>fail then + SetNiceGens(ri,Concatenation(pregensfac(ri),NiceGens(KernelRecogNode(ri)))); else SetNiceGens(ri,pregensfac(ri)); fi; @@ -142,7 +142,7 @@ ConstructActionMatrices := function(ri) AcGens := []; for g in GeneratorsOfGroup(overgroup(ri)) do - Add(AcGens,List(pregensfac(ri),x->ExponentsOfPcElement(Pcgs(RIFac(ri)!.group),ImageElm(Homom(ri),x^g)))); + Add(AcGens,List(pregensfac(ri),x->ExponentsOfPcElement(Pcgs(ImageRecogNode(ri)!.group),ImageElm(Homom(ri),x^g)))); od; return AcGens; @@ -157,15 +157,15 @@ RefineElementaryAbelianLayers := function(ri) if ri=fail then return ri; fi; - rifac := RIFac(ri);; + rifac := ImageRecogNode(ri);; phi := Homom(ri); I := Grp(rifac); if not IsPcGroup(I) or IsCyclic(I) then - riker := RIKer(ri); - SetRIKer(ri,RefineElementaryAbelianLayers(riker)); - if RIKer(ri)<>fail then - SetNiceGens(ri,Concatenation(pregensfac(ri),NiceGens(RIKer(ri)))); + riker := KernelRecogNode(ri); + SetKernelRecogNode(ri,RefineElementaryAbelianLayers(riker)); + if KernelRecogNode(ri)<>fail then + SetNiceGens(ri,Concatenation(pregensfac(ri),NiceGens(KernelRecogNode(ri)))); else SetNiceGens(ri,pregensfac(ri)); fi; @@ -178,10 +178,10 @@ RefineElementaryAbelianLayers := function(ri) #if the module is irreducible then the ChiefSeries can't be refined. if MTX.IsIrreducible(M) then - riker := RIKer(ri); - SetRIKer(ri,RefineElementaryAbelianLayers(riker)); - if RIKer(ri)<>fail then - SetNiceGens(ri,Concatenation(pregensfac(ri),NiceGens(RIKer(ri)))); + riker := KernelRecogNode(ri); + SetKernelRecogNode(ri,RefineElementaryAbelianLayers(riker)); + if KernelRecogNode(ri)<>fail then + SetNiceGens(ri,Concatenation(pregensfac(ri),NiceGens(KernelRecogNode(ri)))); else SetNiceGens(ri,pregensfac(ri)); fi; @@ -195,15 +195,15 @@ RefineElementaryAbelianLayers := function(ri) # get the list of normal subgroups L := List([Length(CS),Length(CS)-1..1],i-> -SubgroupNC(Grp(RIFac(ri)),List(CS[i],v->VectortoPc(v,Grp(RIFac(ri)))))); +SubgroupNC(Grp(ImageRecogNode(ri)),List(CS[i],v->VectortoPc(v,Grp(ImageRecogNode(ri)))))); maps := List([1..Length(L)-1],i->NaturalHomomorphismByNormalSubgroupNC(L[i],L[i+1])); ri := InsertSubTree(ri, rifac, maps);; - riker := RIKer(ri); - SetRIKer(ri,RefineElementaryAbelianLayers(riker)); - SetRIParent(RIKer(ri),ri); - if RIKer(ri)<>fail then - SetNiceGens(ri,Concatenation(pregensfac(ri),NiceGens(RIKer(ri)))); + riker := KernelRecogNode(ri); + SetKernelRecogNode(ri,RefineElementaryAbelianLayers(riker)); + SetRIParent(KernelRecogNode(ri),ri); + if KernelRecogNode(ri)<>fail then + SetNiceGens(ri,Concatenation(pregensfac(ri),NiceGens(KernelRecogNode(ri)))); else SetNiceGens(ri,pregensfac(ri)); fi; @@ -217,8 +217,8 @@ RemoveTrivialLayers := function(ri) if ri=fail then return ri; fi; - rifac := RIFac(ri);; - riker := RIKer(ri);; + rifac := ImageRecogNode(ri);; + riker := KernelRecogNode(ri);; I := Grp(rifac); if IsPcGroup(I) and IsTrivial(I) then # I is trivial!! @@ -232,10 +232,10 @@ RemoveTrivialLayers := function(ri) Unbind(ri!.RIParent); ResetFilterObj(ri, HasRIParent); fi; - newriker := RIKer(ri); - SetRIKer(ri,RemoveTrivialLayers(newriker)); - if RIKer(ri)<>fail then - SetNiceGens(ri,Concatenation(pregensfac(ri),NiceGens(RIKer(ri)))); + newriker := KernelRecogNode(ri); + SetKernelRecogNode(ri,RemoveTrivialLayers(newriker)); + if KernelRecogNode(ri)<>fail then + SetNiceGens(ri,Concatenation(pregensfac(ri),NiceGens(KernelRecogNode(ri)))); else SetNiceGens(ri,pregensfac(ri)); fi; @@ -243,9 +243,9 @@ RemoveTrivialLayers := function(ri) return RemoveTrivialLayers(ri); fi; - SetRIKer(ri,RemoveTrivialLayers(riker)); - if RIKer(ri)<>fail then - SetNiceGens(ri,Concatenation(pregensfac(ri),NiceGens(RIKer(ri)))); + SetKernelRecogNode(ri,RemoveTrivialLayers(riker)); + if KernelRecogNode(ri)<>fail then + SetNiceGens(ri,Concatenation(pregensfac(ri),NiceGens(KernelRecogNode(ri)))); else SetNiceGens(ri,pregensfac(ri)); fi; diff --git a/misc/colva/TopPerms.g b/misc/colva/TopPerms.g index 354054fd2..7358aecc4 100644 --- a/misc/colva/TopPerms.g +++ b/misc/colva/TopPerms.g @@ -3,7 +3,7 @@ MySocleAction:= function(soc, g) local grp; -grp:= PermAction(GroupWithGenerators([g]), Grp(soc), Homom(soc), Grp(RIFac(soc))); +grp:= PermAction(GroupWithGenerators([g]), Grp(soc), Homom(soc), Grp(ImageRecogNode(soc))); if not Size(GeneratorsOfGroup(grp)) = 1 then return fail; fi; @@ -20,12 +20,12 @@ local soc_found, soc, nri, d, R, phi, I, i, Pgens, Pinv_ims, P, perms, nri:= StructuralCopy(ri); soc_found:= false; -while HasRIKer(nri) and not soc_found do - if HasTFordered(RIFac(nri)) and TFordered(RIFac(nri)) = "Socle" then +while HasKernelRecogNode(nri) and not soc_found do + if HasTFordered(ImageRecogNode(nri)) and TFordered(ImageRecogNode(nri)) = "Socle" then soc_found:= true; fi; if not soc_found then - nri:= RIKer(nri); + nri:= KernelRecogNode(nri); fi; od; @@ -37,17 +37,17 @@ fi; #was hoping to use this a short-cut, but it seems that #groups in the socle are not necessarily represented as explicit direct #products. -if not IsDirectProduct(Grp(RIFac(nri))) then +if not IsDirectProduct(Grp(ImageRecogNode(nri))) then SetTFordered(ri, "Pker"); return ri; fi; soc:= nri; -R:= RefineMap(Grp(soc), Homom(soc), Grp(RIFac(soc))); +R:= RefineMap(Grp(soc), Homom(soc), Grp(ImageRecogNode(soc))); phi:= R[1]; I:= R[2]; SetHomom(soc, phi); -SetGrp(RIFac(soc), I); +SetGrp(ImageRecogNode(soc), I); #now we find the degree of the permutation action. Pgens:= [Identity(SymmetricGroup(2))]; @@ -66,27 +66,27 @@ while (HasRIParent(nri)) do #first do the case where this is not a new action - must belong to a lower #factor group or be trivial. if IsSubgroup(P, GroupWithGenerators(perms)) then - if HasTFordered(RIFac(RIKer(nri))) and (RIFac(RIKer(nri))!.TFordered = "Socle") then + if HasTFordered(ImageRecogNode(KernelRecogNode(nri))) and (ImageRecogNode(KernelRecogNode(nri))!.TFordered = "Socle") then #don't reorder, just label this as the beginning of Pker SetTFordered(nri, "Pker"); - elif HasTFordered(RIKer(nri)) and RIKer(nri)!.TFordered = "Pker" then + elif HasTFordered(KernelRecogNode(nri)) and KernelRecogNode(nri)!.TFordered = "Pker" then #move the label for Pker one level higher - Unbind(RIKer(nri)!.TFordered); - ResetFilterObj(RIKer(nri), HasTFordered); + Unbind(KernelRecogNode(nri)!.TFordered); + ResetFilterObj(KernelRecogNode(nri), HasTFordered); SetTFordered(nri, "Pker"); else ki:= GroupHomomorphismByImagesNC(P, overgroup(soc), Pgens, Pinv_ims); #have to move down below all bits that act nontrivially on socle. - while not (HasTFordered(RIFac(RIKer(nri))) and - RIFac(RIKer(nri))!.TFordered = "Socle") do - if IsBound(Grp(RIFac(RIKer(nri)))!.Pcgs) then + while not (HasTFordered(ImageRecogNode(KernelRecogNode(nri))) and + ImageRecogNode(KernelRecogNode(nri))!.TFordered = "Socle") do + if IsBound(Grp(ImageRecogNode(KernelRecogNode(nri)))!.Pcgs) then #move past a (soluble) PC group - pgs:= pregensfac(RIKer(nri)); + pgs:= pregensfac(KernelRecogNode(nri)); pgs_ims:= List(pgs, x->x*Image(ki,MySocleAction(soc, x))^-1); - alpha:= GroupHomomorphismByImagesNC(Grp(RIFac(RIKer(nri))), overgroup(nri), pgs, pgs_ims); + alpha:= GroupHomomorphismByImagesNC(Grp(ImageRecogNode(KernelRecogNode(nri))), overgroup(nri), pgs, pgs_ims); zeta:= function(g) - return Image(Homom(RIKer(nri)),(g*Image(alpha, - Image(Homom(RIKer(nri)), g))^-1)); + return Image(Homom(KernelRecogNode(nri)),(g*Image(alpha, + Image(Homom(KernelRecogNode(nri)), g))^-1)); end; else #should have a nonabelian group to move past here, diff --git a/misc/colva/leaves.g b/misc/colva/leaves.g index c9d24dc81..757f9186f 100644 --- a/misc/colva/leaves.g +++ b/misc/colva/leaves.g @@ -125,7 +125,7 @@ function(ri,I,name) Objectify(RecognitionInfoType,rifac);; SetFilterObj(rifac,IsLeaf); SetRIParent(rifac,ri); - SetRIFac(ri,rifac); + SetImageRecogNode(ri,rifac); SetGrp(rifac,I); if IsPcGroup(I) then bool := SolveLeafPc(ri,rifac); diff --git a/misc/colva/stuff.g b/misc/colva/stuff.g index 3faabe9e5..b5dddb497 100644 --- a/misc/colva/stuff.g +++ b/misc/colva/stuff.g @@ -1,4 +1,4 @@ -InstallMethod(\=, [IsRecognitionInfo,IsRecognitionInfo], IsIdenticalObj); +InstallMethod(\=, [IsRecogNode,IsRecogNode], IsIdenticalObj); #utility function to check that parents and kernels are working. @@ -7,19 +7,19 @@ local nri, i, bool; nri:= StructuralCopy(ri); i:= 0; bool:= true; -while HasRIKer(nri) and not RIKer(nri) = fail do - if not RIParent(RIFac(nri)) = nri then +while HasKernelRecogNode(nri) and not KernelRecogNode(nri) = fail do + if not RIParent(ImageRecogNode(nri)) = nri then Print("factor error at level", i, "\n"); bool:= false; fi; - if not RIParent(RIKer(nri)) = nri then + if not RIParent(KernelRecogNode(nri)) = nri then Print("error: at level", i, "\n"); bool:= false; fi; - nri:= RIKer(nri); + nri:= KernelRecogNode(nri); i:= i+1; od; -if not RIParent(RIFac(nri)) = nri then +if not RIParent(ImageRecogNode(nri)) = nri then Print("factor error at level", i, "\n"); fi; return bool; diff --git a/tst/broken/veryslow/ClassicalNatural.tst b/tst/broken/veryslow/ClassicalNatural.tst index 6fa6980f2..3c911c748 100644 --- a/tst/broken/veryslow/ClassicalNatural.tst +++ b/tst/broken/veryslow/ClassicalNatural.tst @@ -8,10 +8,10 @@ gap> TestRecogGL := function(d,q) > g := GroupWithGenerators(gens); > ri := RECOG.TestGroup(g,false,Size(h)); > r := ri; -> if not IsLeaf(ri) then r := RIFac(ri); fi; +> if not IsLeaf(ri) then r := ImageRecogNode(ri); fi; > stamp := r!.fhmethsel.successMethod; > if stamp="ProjDeterminant" then -> r := RIKer(r); +> r := KernelRecogNode(r); > stamp := r!.fhmethsel.successMethod; > fi; > Print("Stamp: ",stamp,"\n"); diff --git a/tst/testclassicalnatural.g b/tst/testclassicalnatural.g index 11b3360fa..0ac88d95f 100644 --- a/tst/testclassicalnatural.g +++ b/tst/testclassicalnatural.g @@ -13,10 +13,10 @@ for q in [2,3,4,5,7,8,9,11,13,16,17,25,81,256] do Print("Testing GL(",d,",",q,") in its natural representation...\n"); ri := RECOG.TestGroup(g,false,Size(h)); r := ri; - if not IsLeaf(ri) then r := RIFac(ri); fi; + if not IsLeaf(ri) then r := ImageRecogNode(ri); fi; stamp := r!.fhmethsel.successMethod; if stamp="ProjDeterminant" then - r := RIKer(r); + r := KernelRecogNode(r); stamp := r!.fhmethsel.successMethod; fi; Print("Stamp: ",stamp,"\n\n"); diff --git a/tst/working/quick/mixed.tst b/tst/working/quick/mixed.tst index 0291cad8f..1bb188ff1 100644 --- a/tst/working/quick/mixed.tst +++ b/tst/working/quick/mixed.tst @@ -7,5 +7,5 @@ gap> gens[1][1][2] := -gens[1][1][2];; gens[2][7][5] := -gens[2][7][5];; gap> H2:=Group(gens);; gap> # FIXME: test disabled for now, as it sometimes fails gap> #ri:=RECOG.TestGroup(H2, false, 645120);; -gap> #IsMatrixGroup(Grp(RIFac(ri))); -gap> #IsPermGroup(Grp(RIFac(RIFac(ri)))); +gap> #IsMatrixGroup(Grp(ImageRecogNode(ri))); +gap> #IsPermGroup(Grp(ImageRecogNode(ImageRecogNode(ri)))); diff --git a/tst/working/veryslow/ClassicalNatural.tst b/tst/working/veryslow/ClassicalNatural.tst index da274429a..adecb4dd6 100644 --- a/tst/working/veryslow/ClassicalNatural.tst +++ b/tst/working/veryslow/ClassicalNatural.tst @@ -8,10 +8,10 @@ gap> TestRecogGL := function(d,q) > g := GroupWithGenerators(gens); > ri := RECOG.TestGroup(g,false,Size(h)); > r := ri; -> if not IsLeaf(ri) then r := RIFac(ri); fi; +> if not IsLeaf(ri) then r := ImageRecogNode(ri); fi; > stamp := r!.fhmethsel.successMethod; > if stamp="ProjDeterminant" then -> r := RIKer(r); +> r := KernelRecogNode(r); > stamp := r!.fhmethsel.successMethod; > fi; > Print("Stamp: ",stamp,"\n");