Daniels constructive recognition code

gap/projective/classicalnatural.gi

@@ -4,7 +4,7 @@
 ##  which provides a collection of methods for the constructive recognition
 ##  of groups.
 ##
-##  This files's authors include Max Neunhöffer, Ákos Seress.
+##  This files's authors include Daniel Rademacher, Max Neunhöffer, Ákos Seress.
 ##
 ##  Copyright of recog belongs to its developers whose names are too numerous
 ##  to list here. Please refer to the COPYRIGHT file for details.
@@ -17,45 +17,6 @@
 ##
 #############################################################################
 
-InstallMethod( Eigenspaces, "for a field and a memory element matrix",
-  [ IsField, IsMatrix and IsObjWithMemory ],
-  function( f, m )
-    return Eigenspaces(f,m!.el);
-  end );
-
-RECOG.FindStdGensUsingBSGS := function(g,stdgens,projective,large)
-  # stdgens generators for the matrix group g
-  # returns an SLP expressing stdgens in the generators of g
-  # set projective to true for projective mode
-  # set large to true if we should not bother finding nice base points!
-  local S,dim,gens,gm,i,l,strong;
-  dim := DimensionOfMatrixGroup(g);
-  if IsObjWithMemory(GeneratorsOfGroup(g)[1]) then
-      gm := GroupWithMemory(StripMemory(GeneratorsOfGroup(g)));
-  else
-      gm := GroupWithMemory(g);
-  fi;
-  if HasSize(g) then SetSize(gm,Size(g)); fi;
-  if large then
-      S := StabilizerChain(gm,rec( Projective := projective,
-        Cand := rec( points := One(g),
-                     ops := ListWithIdenticalEntries(dim, OnLines) ) ) );
-  else
-      S := StabilizerChain(gm,rec( Projective := projective ) );
-  fi;
-  strong := ShallowCopy(StrongGenerators(S));
-  ForgetMemory(S);
-  l := List(stdgens,x->SiftGroupElementSLP(S,x));
-  gens := EmptyPlist(Length(stdgens));
-  for i in [1..Length(stdgens)] do
-      if not l[i].isone then
-          return fail;
-      fi;
-      Add(gens,ResultOfStraightLineProgram(l[i].slp,strong));
-  od;
-  return SLPOfElms(gens);
-end;
-
 RECOG.ResetSLstd := function(r)
   r.left := One(r.a);
   r.right := One(r.a);
@@ -352,27 +313,6 @@ end;
 
 
 
-RECOG.RecogniseSL2NaturalOddCharUsingBSGS := function(g,f)
-  local ext,p,q,res,slp,std;
-  p := Characteristic(f);
-  ext := DegreeOverPrimeField(f);
-  q := Size(f);
-  std := RECOG.MakeSL_StdGens(p,ext,2,2);
-  slp := RECOG.FindStdGensUsingBSGS(g,std.all,false,true);
-  if slp = fail then
-      return fail;
-  fi;
-  res := rec( g := g, one := One(f), One := One(g), f := f, q := q,
-              p := p, ext := ext, d := 2, bas := IdentityMat(2,f),
-              basi := IdentityMat(2,f) );
-  res.all := ResultOfStraightLineProgram(slp,GeneratorsOfGroup(g));
-  res.s := res.all{[1..ext]};
-  res.t := res.all{[ext+1..2*ext]};
-  res.a := res.all[2*ext+1];
-  res.b := res.all[2*ext+2];
-  return res;
-end;
-
 RECOG.RecogniseSL2NaturalEvenChar := function(g,f,torig)
   # f a finite field, g equal to SL(2,Size(f)), t either an involution
   # or false.
@@ -394,7 +334,8 @@ RECOG.RecogniseSL2NaturalEvenChar := function(g,f,torig)
   fi;
   if torig = false then
     # if no involution t has been given, compute one, using Proposition 4 from
-    # [KK15].
+    # "Black box groups isomorphic to PGL(2,2^e)" by Kantor & Kassabov,
+    # Journal of Algebra, 421 (2015) 16–26.
     repeat
         am:=PseudoRandom(g);
     until not IsOneProjective(am);

gap/projective/constructive_recognition/O/BaseCase.gi

@@ -0,0 +1,32 @@
+#############################################################################
+##
+##  This file is part of recog, a package for the GAP computer algebra system
+##  which provides a collection of methods for the constructive recognition
+##  of groups.
+##
+##  This files's authors include Daniel Rademacher.
+##
+##  Copyright of recog belongs to its developers whose names are too numerous
+##  to list here. Please refer to the COPYRIGHT file for details.
+##
+##  SPDX-License-Identifier: GPL-3.0-or-later
+##
+#############################################################################
+
+
+
+#############################################################################
+#############################################################################
+######## BaseCase algorithm for orthogonal groups ###########################
+#############################################################################
+#############################################################################
+
+
+
+# Find isomorphism from POmega(5,q) to PSp(4,q) and
+# use constructive recognition of PSp(4,q)
+RECOG.ConstructiveRecognitionOfSO6 := function(h,q,form)
+
+    # TODO
+
+end;

gap/projective/constructive_recognition/O/GoingDown.gi

@@ -0,0 +1,122 @@
+#############################################################################
+##
+##  This file is part of recog, a package for the GAP computer algebra system
+##  which provides a collection of methods for the constructive recognition
+##  of groups.
+##
+##  This files's authors include Daniel Rademacher.
+##
+##  Copyright of recog belongs to its developers whose names are too numerous
+##  to list here. Please refer to the COPYRIGHT file for details.
+##
+##  SPDX-License-Identifier: GPL-3.0-or-later
+##
+#############################################################################
+
+
+
+#############################################################################
+#############################################################################
+######## GoingDown method for orthogonal groups #############################
+#############################################################################
+#############################################################################
+
+
+
+RECOG.SO_godownToDimension6 := function(h,q)
+local counter, ele, x, x2, ord, invo, found, cent, product, eigenspace, Minuseigenspace, newbasis, dimeigen, dimMinuseigen, r1, r2, result;
+
+    # First we construct an involution i in h
+
+    found := false;
+    for counter in [1..100] do
+        ele := PseudoRandom(h);
+        x := RECOG.EstimateOrder(ele);
+        x2 := x[2];
+        ord := x[3];
+        if x2 <> One(h) then
+            invo := x2^(ord/2);
+        else
+            invo := One(h);
+        fi;
+
+        if invo <> One(h) and invo^2 = One(h) then
+            eigenspace := Eigenspaces(GF(q),invo);
+            if Size(eigenspace) <> 1 then
+                Minuseigenspace := eigenspace[2];
+                eigenspace := eigenspace[1];
+                dimeigen := Dimension(eigenspace);
+                dimMinuseigen := Dimension(Minuseigenspace);
+                if dimeigen = 6 or dimMinuseigen = 6 then
+                    found := true;
+                    break;
+                fi;
+            fi;
+        fi;
+    od;
+
+    if not(found) then
+        Error("could not find an involution");
+    fi;
+
+    newbasis := MutableCopyMat(BasisVectors(Basis(eigenspace)));
+    Append(newbasis,BasisVectors(Basis(Minuseigenspace)));
+
+    # Second we compute the two factors by computing the centralizer of the involution i
+
+    cent := RECOG.CentraliserOfInvolution(h,invo,[],true,100,RECOG.CompletionCheck,PseudoRandom);
+    product := GroupByGenerators(cent[1]);
+
+    # Third we continue as in "Constructive recognition of classical groups in odd characteristic" part 11 to find generator
+
+    if dimeigen = 6 then
+        r1 := [1..dimeigen];
+        r2 := [7,8];
+    else
+        r1 := [dimeigen+1..8];
+        r2 := [1,2];
+    fi;
+    for counter in [1..100] do
+        result := RECOG.ConstructSmallSub(r1, r2, product, newbasis, g -> RecogniseClassical(g).isSOContained);
+        if result <> fail then
+            break;
+        fi;
+    od;
+
+    return result;
+
+end;
+
+
+
+RECOG.SOn_constructso2:=function(g,d,q,form)
+local r,h,basechange,basechange2,slp,liftbasechange2,liftr;
+
+    r := RECOG.constructppdTwoStingray(g,d,q,"O",form);
+    Info(InfoRecog,2,"Finished main GoingDown, i.e. we found a stringray element which operates irreducible on a 8 dimensional subspace. \n");
+    # Remark D.R.: at this point we know that h is isomorphic to Omega(8,q)
+    Info(InfoRecog,2,"Succesful. ");
+    Info(InfoRecog,2,"Current Dimension: 8\n");
+    Info(InfoRecog,2,"Next goal: Generate Omega(4,q). \n");
+    if IsEvenInt(q) then
+        basechange := RECOG.ComputeBlockBaseChangeMatrix(GeneratorsOfGroup(r),d,q);
+        liftr := List(GeneratorsOfGroup(r),x->x^(basechange^(-1)));
+        return [GroupByGenerators(liftr),basechange];
+    else
+        # For now, compute a base change into the stingray matrices
+        basechange := RECOG.ComputeBlockBaseChangeMatrix(GeneratorsOfGroup(r),d,q);
+        #slp := SLPOfElms(GeneratorsOfGroup(r));
+
+        r := RECOG.SO_godownToDimension6(RECOG.ExtractSmallerGroup(GeneratorsOfGroup(r),basechange,8)[1],q);
+        basechange2 := RECOG.ComputeBlockBaseChangeMatrix(r[1],8,q);
+        liftbasechange2 := RECOG.LiftGroup([basechange2],8,q,d)[2,1];
+        liftr := RECOG.LiftGroup(r[1],8,q,d)[2];
+
+        liftr := List(liftr,x->x^(liftbasechange2^(-1)));
+        #slp := CompositionOfStraightLinePrograms(SLPOfElms(r[1]),slp);
+        # Remark D.R.: at this point we know that h is isomorphic to Sp(6,q)
+
+        return [GroupByGenerators(liftr),liftbasechange2*basechange];
+    #   return ["sorry only SL(4,q)",h];
+    fi;
+end;