WIP: mandarins

Author: fingolfin

gap/base/recognition.gd

@@ -445,6 +445,12 @@ BindGlobal( "SLPforElementFuncsGeneric", rec() );
 
 DeclareGlobalFunction( "EmptyRecognitionInfoRecord" );
 
+# TODO Document mandarins
+# Refer to overview paper by Baarnhielm, Holt, Charles, Eamonn, sections "5.2
+# The main algorithm" and "5.4 Crisis management".
+# Explain safe and unsafe nodes.
+BindGlobal("MANDARIN_CRISIS", MakeImmutable("MANDARIN_CRISIS"));
+
 ## <#GAPDoc Label="RecognisePermGroup">
 ## <ManSection>
 ## <Func Name="RecognisePermGroup" Arg="H"/>

gap/base/recognition.gi

@@ -91,25 +91,25 @@ InstallMethod( ViewObj, "for recognition nodes", [IsRecogNode],
 
 InstallGlobalFunction( RecognisePermGroup,
   function(G)
-    return RecogniseGeneric(G, FindHomDbPerm, "", rec());
+    return RecogniseGeneric(G, FindHomDbPerm, "", rec(), fail);
   end);
 
 InstallGlobalFunction( RecogniseMatrixGroup,
   function(G)
-    return RecogniseGeneric(G, FindHomDbMatrix, "", rec());
+    return RecogniseGeneric(G, FindHomDbMatrix, "", rec(), fail);
   end);
 
 InstallGlobalFunction( RecogniseProjectiveGroup,
   function(G)
-    return RecogniseGeneric(G, FindHomDbProjective, "", rec());
+    return RecogniseGeneric(G, FindHomDbProjective, "", rec(), fail);
   end);
 
 InstallGlobalFunction( RecogniseGroup,
   function(G)
     if IsPermGroup(G) then
-        return RecogniseGeneric(G, FindHomDbPerm, "", rec());
+        return RecogniseGeneric(G, FindHomDbPerm, "", rec(), fail);
     elif IsMatrixGroup(G) then
-        return RecogniseGeneric(G, FindHomDbMatrix, "", rec());
+        return RecogniseGeneric(G, FindHomDbMatrix, "", rec(), fail);
     else
         ErrorNoReturn("Only matrix and permutation groups are supported");
     fi;
@@ -435,22 +435,33 @@ InstallGlobalFunction( PrintTreePos,
     fi;
   end );
 
+NUM_MANDARINS := 100;
+
 InstallGlobalFunction( RecogniseGeneric,
-  function(H, methoddb, depthString, knowledge)
+  function(H, methoddb, depthString, knowledge, mandarins)
     # Assume all the generators have no memory!
-    local N,depth,done,i,l,ll,allmethods,
-          hint,
-          proj1,proj2,ri,rifac,riker,s,x,y,z,succ,counter;
+    TODO
 
     depth := Length(depthString);
 
     PrintTreePos("E",depthString,H);
     Info(InfoRecog,4,"Recognising: ",H);
 
     if Length(GeneratorsOfGroup(H)) = 0 then
+        # FIXME: shouldn't we just, like, finish here immediately?
         H := Group([One(H)]);
     fi;
 
+    if mandarins = fail then
+        Assert(0, depth = 0);
+        # HACK: We don't want the mandarins to be reused by any computation.
+        # Since PseudoRandom is hacked, it is important that we generate the
+        # mandarins before calling EmptyRecognitionInfoRecord. Otherwise the
+        # mandarins would be reused by RandomElm and RandomElmOrd.
+        mandarins := List([1..NUM_MANDARINS], i -> PseudoRandom(H));
+    fi;
+
+
     # Set up the record and the group object:
     if IsIdenticalObj( methoddb, FindHomDbProjective ) then
         ri := EmptyRecognitionInfoRecord(knowledge,H,true);
@@ -504,6 +515,16 @@ InstallGlobalFunction( RecogniseGeneric,
                 SetNiceGens(ri,GeneratorsOfGroup(H));
             fi;
         fi;
+
+        # TODO: store the mandarins and their SLPs?
+        # check mandarins now
+        for x in mandarins do
+            s := SLPforElement(ri, x);
+            if s = fail then
+                return MANDARIN_CRISIS;
+            fi;
+        od;
+
         # these two were set correctly by FindHomomorphism
         if IsLeaf(ri) then SetFilterObj(ri,IsReady); fi;
         # FIXME: settle what IsReady means *exactly*;
@@ -517,6 +538,21 @@ InstallGlobalFunction( RecogniseGeneric,
 
     # The non-leaf case:
     # In that case we know that ri now knows: homom plus additional data.
+    
+    # Compute the mandarins of the factor
+    for x in mandarins do
+        if not ValidateHomomInput(ri, x) then
+            # TODO
+            return MANDARIN_CRISIS;
+        fi;
+    od;
+    factorMandarins := [];
+    for x in mandarins do
+        y := ImageElm(Homom(ri), x);
+        Assert(2, y <> fail);
+        Add(factorMandarins, y);
+    od;
+    # TODO: sort the factorMandarins and remove duplicates and trivials
 
     # Try to recognise the image a few times, then give up:
     counter := 0;
@@ -538,14 +574,23 @@ InstallGlobalFunction( RecogniseGeneric,
         fi;
         if ForAny(GeneratorsOfGroup(H), x->not ValidateHomomInput(ri, x)) then
             # Our group fails to contain some of the generators of H!
-            return fail;
+            # We handle this in the same way as if a ValidateHomomInpu had
+            # returned fail for a mandarin.
+            return MANDARIN_CRISIS;
         fi;
 
         Add(depthString,'F');
         rifac := RecogniseGeneric(
                   Group(List(GeneratorsOfGroup(H), x->ImageElm(Homom(ri),x))),
-                  methodsforimage(ri), depthString, InitialDataForImageRecogNode(ri) ); # TODO: change InitialDataForImageRecogNode to hintsForFactor??)
+                  methodsforimage(ri), depthString, InitialDataForImageRecogNode(ri)
+                  factorMandarins);
         Remove(depthString);
+        # According to the mandarins, there was an error in a kernel generation
+        # higher up in the recognition tree. Since rifac was a factor node, it
+        # must have been `not safe`.
+        if rifac = MANDARIN_CRISIS then
+            return MANDARIN_CRISIS;
+        fi;
         PrintTreePos("F",depthString,H);
         SetImageRecogNode(ri,rifac);
         SetParentRecogNode(rifac,ri);
@@ -558,7 +603,11 @@ InstallGlobalFunction( RecogniseGeneric,
             Info(InfoRecog,2,"Back from image (depth=",depth,").");
         fi;
 
+        # TODO: I think we should get rid of all the IsReady stuff. The
+        # manual says it's "mainly set for debugging purposes". Then why does
+        # it influence how often we try recognising the factor?
         if not IsReady(rifac) then
+            # FIXME: why should we give up here?
             # the recognition of the image failed, also give up here:
             if InfoLevel(InfoRecog) = 1 and depth = 0 then Print("\n"); fi;
             return ri;
@@ -569,6 +618,8 @@ InstallGlobalFunction( RecogniseGeneric,
         ri!.pregensfacwithmem := CalcNiceGens(rifac, ri!.gensHmem);
         Setpregensfac(ri, StripMemory(ri!.pregensfacwithmem));
 
+        # TODO: If mapping the mandarins failed, then we need to backtrack to
+        # the last safe node and then add more kernel generators here (I think).
         # Now create the kernel generators with the stored method:
         succ := CallFuncList(findgensNmeth(ri).method,
                              Concatenation([ri],findgensNmeth(ri).args));
@@ -585,7 +636,7 @@ InstallGlobalFunction( RecogniseGeneric,
         Sort(l,SortFunctionWithMemory);   # this favours "shorter" memories!
         # FIXME: For projective groups different matrices might stand
         #        for the same element, we might overlook this here!
-        # remove duplicates:
+        # remove duplicates and trivial entries:
         ll := [];
         for i in [1..Length(l)] do
             if not isone(ri)(l[i]) and
@@ -595,13 +646,40 @@ InstallGlobalFunction( RecogniseGeneric,
         od;
         SetgensN(ri,ll);
     fi;
+    # evaluate mandarins to get kernel mandarins
+    # TODO: something is suuper iffy about the method BlocksModScalars, which
+    # is called by BlockDiagonal.
+    # Apparently its input is neither to be understood as a projective nor as a
+    # matrix group, but rather as a "all block-scalars being trivial" group.
+    # That ofc completely wrecks the mandarins, since they assume the group to
+    # be projective.
+    kernelMandarins := [];
+    for i in [1..Length(mandarins)] do
+        x := mandarins[i];
+        y := factorMandarins[i];
+        s := SLPforElement(rifac, y);
+        # TODO: these SLPs should be stored when they are computed for the
+        # first time.
+        if s = fail then
+            Error("TODO: no SLP for factor");
+        fi;
+        z := ResultOfStraightLineProgram(s, pregensfac(ri));
+        if not ri!.isequal(x, z) then
+            Add( kernelMandarins, x / z );
+        fi;
+    od;
+    # TODO: sort the kernelMandarins and remove duplicates and trivials
+
     if IsEmpty(gensN(ri)) and immediateverification(ri) then
         # Special case, for an explanation see the source of the called function.
         RECOG_HandleSpecialCaseKernelTrivialAndMarkedForImmediateVerification(ri);
     fi;
     if IsEmpty(gensN(ri)) then
-        # We found out that N is the trivial group!
-        # In this case we do nothing, kernel is fail indicating this.
+        # We found out that N is the trivial group! If the mandarins agree, we
+        # do nothing. Set the kernel to fail to indicate this.
+        if Length(kernelMandarins) <> 0 then
+            return MANDARIN_CRISIS;
+        fi;
         Info(InfoRecog,2,"Found trivial kernel (depth=",depth,").");
         SetKernelRecogNode(ri,fail);
         # We have to learn from the image, what our nice generators are:
@@ -613,6 +691,8 @@ InstallGlobalFunction( RecogniseGeneric,
     fi;
 
     Info(InfoRecog,2,"Going to the kernel (depth=",depth,").");
+    # If we do immediate verification, then we may have to recognise the kernel
+    # several times.
     repeat
         # Now we go on as usual:
         SetgensNslp(ri,SLPOfElms(gensN(ri)));
@@ -622,8 +702,22 @@ InstallGlobalFunction( RecogniseGeneric,
         N := Group(StripMemory(gensN(ri)));
 
         Add(depthString,'K');
-        riker := RecogniseGeneric( N, methoddb, depthString, InitialDataForKernelRecogNode(ri) );
+        riker := RecogniseGeneric( N, methoddb, depthString,
+                                   InitialDataForKernelRecogNode(ri),
+                                   kernelMandarins );
         Remove(depthString);
+        # According to the mandarins, there was an error in the kernel
+        # generation of the current node or higher up in the recognition tree.
+        # We have to backtrack to the highest unsafe node.
+        if riker = MANDARIN_CRISIS and not IsSafeRI(RIParent) then
+            return MANDARIN_CRISIS;
+        elif riker = MANDARIN_CRISIS and IsSafeRI(RIParent) then;
+            # b) we are the "highest" unsafe node. TODO:
+            #    - cut off the part of the tree rooted in the current node,
+            #    - add generators to the kernel
+            #    - restart the kernel recognition
+            ErrorNoReturn("TODO");
+        fi;
         PrintTreePos("K",depthString,H);
         SetKernelRecogNode(ri,riker);
         SetParentRecogNode(riker,ri);
@@ -634,7 +728,15 @@ InstallGlobalFunction( RecogniseGeneric,
             Info(InfoRecog,2,"Doing immediate verification (depth=",
                  depth,").");
             done := ImmediateVerification(ri);
+            # TODO: If immediate verification fails because of image
+            # computations, then:
+            # return MANDARIN_CRISIS;
         fi;
+        for x in kernelMandarins do
+            if SLPforElement(ri, x) = fail then
+                return MANDARIN_CRISIS;
+            fi;
+        od;
     until done;
 
     if IsReady(riker) then    # we are only ready when the kernel is
@@ -1051,42 +1153,3 @@ RECOG.testAllSubgroups := function(g, options...)
         CallFuncList(RECOG.TestGroup, Concatenation([sub, false, Size(sub)],options));
     od;
 end;
-
-
-RECOG.TestRecognitionNode := function(ri,stop,recurse)
-  local err, grp, x, slp, y, ef, ek, i;
-  err := 0;
-  grp := Grp(ri);
-  for i in [1..100] do
-      x := PseudoRandom(grp);
-      slp := SLPforElement(ri,x);
-      if slp <> fail then
-          y := ResultOfStraightLineProgram(slp,NiceGens(ri));
-      fi;
-      if slp = fail or not ri!.isone(x/y) then
-          if stop then ErrorNoReturn("ErrorNoReturn found, look at x, slp and y"); fi;
-          err := err + 1;
-          Print("X\c");
-      else
-          Print(".\c");
-      fi;
-  od;
-  Print("\n");
-  if err > 0 and recurse then
-      if IsLeaf(ri) then
-          return rec(err := err, badnode := ri);
-      fi;
-      ef := RECOG.TestRecognitionNode(ImageRecogNode(ri),stop,recurse);
-      if IsRecord(ef) then
-          return ef;
-      fi;
-      if KernelRecogNode(ri) <> fail then
-          ek := RECOG.TestRecognitionNode(KernelRecogNode(ri),stop,recurse);
-          if IsRecord(ek) then
-              return ek;
-          fi;
-      fi;
-      return rec( err := err, badnode := ri, factorkernelok := true );
-  fi;
-  return err;
-end;