Introduce explicit field argument and reduce reliance on DefaultFieldOfMatrixGroup (#135)

* Add field argument to ConjugateToSesquilinearForm and ConjugateToStandardForm
* Refactor DefaultFieldOfMatrixGroup usage, update tests/docs

Author: chseeger

gap/ClassicalNormalizerMatrixGroups.gi

@@ -12,7 +12,8 @@ function(d, q)
 
     AandB := ShallowCopy(GeneratorsOfGroup(ConjugateToSesquilinearForm(Sp(d, q), 
                                                                        "S", 
-                                                                       standardForm)));
+                                                                       standardForm,
+                                                                       F)));
     gcd := Gcd(d, q - 1);
     # generates the center of SL(d, q)
     C := zeta ^ QuoInt(q - 1, gcd) * IdentityMat(d, F);
@@ -57,7 +58,7 @@ function(d, q)
     C := zeta^(QuoInt((q - 1), Gcd(q - 1, d))) * IdentityMat(d, F); # generates the center of SL(d, q)
     g := Gcd(q - 1, d);
     c := QuoInt(Gcd(q0 + 1, d) * (q - 1), Lcm(q0 + 1, QuoInt(q - 1, g)) * g);
-    SUWithIdentityForm := ConjugateToSesquilinearForm(SU(d, q0), "U", IdentityMatrix(GF(q0), d));
+    SUWithIdentityForm := ConjugateToSesquilinearForm(SU(d, q0), "U", IdentityMatrix(GF(q0), d), F);
     SUGens := GeneratorsOfGroup(SUWithIdentityForm);
 
     gens := Concatenation(SUGens, [C]);
@@ -174,5 +175,5 @@ function(epsilon, d, q)
         ErrorNoReturn("<q> must be even");
     fi;
 
-    return ConjugateToStandardForm(SO(epsilon, d, q), "S");
+    return ConjugateToStandardForm(SO(epsilon, d, q), "S", GF(q));
 end);

gap/ExtraspecialNormalizerMatrixGroups.gi

@@ -733,7 +733,7 @@ function(r, m, q)
     # We conjugate the group so that it preserves the standard GAP form
     # Antidiag(1, ..., 1). 
     SetInvariantSesquilinearForm(result, rec(matrix := IdentityMat(r ^ m, F)));
-    result := ConjugateToStandardForm(result, "U");
+    result := ConjugateToStandardForm(result, "U", F);
 
     return result;
 end);
@@ -763,7 +763,7 @@ function(m, q)
                                                 List([1..2 ^ (m - 1)],
                                                      i -> [2 * i, 2 * i - 1, -1])));
     SetInvariantBilinearForm(result, rec(matrix := gramMatrix));
-    result := ConjugateToStandardForm(result, "S");
+    result := ConjugateToStandardForm(result, "S", F);
 
     return result;
 end);
@@ -782,7 +782,7 @@ function(m, q)
     # This group now preserves the bilinear form given by the identity matrix
     # and we conjugate it so that it preserves the standard GAP form
     SetInvariantBilinearForm(result, rec(matrix := IdentityMat(2 ^ m, F)));
-    result := ConjugateToStandardForm(result, "O+");
+    result := ConjugateToStandardForm(result, "O+", F);
 
     return result;
 end);

gap/Forms.gi

@@ -20,26 +20,21 @@ function(gramMatrix)
     return Q;
 end);
 
-# One needs to ensure that the attribute DefaultFieldOfMatrixGroup is set
-# correctly for <group>; this can be done, for example, by making the
-# generators used during construction of the group immutable matrices over the
-# appropriate field.
 InstallGlobalFunction("ConjugateToSesquilinearForm",
-function(group, type, gramMatrix)
-    local gapForm, newForm, baseChangeMatrix, field, formMatrix,
+function(group, type, gramMatrix, field)
+    local gapForm, newForm, baseChangeMatrix, formMatrix,
         result, d, q, broadType;
     if not type in ["S", "O-B", "O-Q", "U"] then
         ErrorNoReturn("<type> must be one of 'S', 'U', 'O-B', 'O-Q'");
     fi;
     d := DimensionOfMatrixGroup(group);
-    field := DefaultFieldOfMatrixGroup(group);
     if type = "S" or type = "O-B" then
         if type = "S" then
             broadType := type;
         else
             broadType := "O";
         fi;
-        formMatrix := BilinearForm(group, broadType);
+        formMatrix := BilinearForm(group, broadType, field);
         if formMatrix = fail then
             if type = "S" then
                 ErrorNoReturn("No preserved symplectic form found for <group>");
@@ -55,15 +50,15 @@ function(group, type, gramMatrix)
             q := Size(field);
             field := GF(q ^ 2);
         fi;
-        formMatrix := UnitaryForm(group);
+        formMatrix := UnitaryForm(group, field);
         if formMatrix = fail then
             ErrorNoReturn("No preserved unitary form found for <group>");
         fi;
         gapForm := HermitianFormByMatrix(formMatrix, field);
         newForm := HermitianFormByMatrix(gramMatrix, field);
     else
         # This is the case type = "O-Q"
-        formMatrix := QuadraticForm(group);
+        formMatrix := QuadraticForm(group, field);
         if formMatrix = fail then
             ErrorNoReturn("No preserved quadratic form found for <group>");
         fi;
@@ -112,42 +107,32 @@ end);
 # If <group> preserves a sesquilinear form of type <type> (one of "S", "U", "O"
 # (in odd dimension), "O+" or "O-" (both in even dimension), return a group
 # conjugate to <group> preserving the standard form of that type.
-#
-# Also, one need to ensure that the attribute DefaultFieldOfMatrixGroup is set
-# correctly for <group>; this can be done, for example, by making the
-# generators used during construction of the group immutable matrices over the
-# appropriate field.
 InstallGlobalFunction("ConjugateToStandardForm",
-function(group, type)
-    local d, F, q, gapForm, broadType;
+function(group, type, field)
+    local d, q, gapForm, broadType;
 
     # determining d (dimension of matrix group), F (base field) and q (order of
     # F) plus some sanity checks
     if not type in ["S", "O+", "O-", "O", "U"] then
         ErrorNoReturn("<type> must be one of 'S', 'U', 'O+', 'O-', 'O'");
     fi;
-    F := DefaultFieldOfMatrixGroup(group);
     d := DimensionOfMatrixGroup(group);
     if type = "O" and IsEvenInt(d) then
         ErrorNoReturn("<type> cannot be 'O' if the dimension of <group> is even");
     elif type in ["O+", "O-"] and IsOddInt(d) then
         ErrorNoReturn("<type> cannot be 'O+' or 'O-' if the dimension of",
                       " <group> is odd");
-    elif IsEvenInt(Size(F)) and IsOddInt(d) and type in ["O+", "O-", "O"] then
+    elif IsEvenInt(Size(field)) and IsOddInt(d) and type in ["O+", "O-", "O"] then
         ErrorNoReturn("If <type> is 'O+', 'O-' or 'O' and the size of <F> is",
                       " even, <d> must be even");
     fi;
     if type in ["S", "O", "O+", "O-"] then
-        q := Size(F);
+        q := Size(field);
     else
-        if IsSquareInt(Size(F)) then
-            q := RootInt(Size(F));
+        if IsSquareInt(Size(field)) then
+            q := RootInt(Size(field));
         else
-            # It might be that G is to be understood as a matrix group over 
-            # GF(q ^ 2), but the matrices can actually be represented over a
-            # smaller field, which causes DefaultFieldOfMatrixGroup to return GF(q)
-            # instead of GF(q ^ 2) - we have to remedy this somehow ...
-            q := Size(F);
+            q := Size(field);
         fi;
     fi;
 
@@ -159,21 +144,21 @@ function(group, type)
     elif type = "O" then
         gapForm := InvariantBilinearForm(Omega(d, q)).matrix;
     elif type = "O+" then
-        if Characteristic(F) = 2 then
+        if Characteristic(field) = 2 then
             gapForm := InvariantQuadraticForm(Omega(1, d, q)).matrix;
         else
             gapForm := InvariantBilinearForm(Omega(1, d, q)).matrix;
         fi;
     elif type = "O-" then
-        if Characteristic(F) = 2 then
+        if Characteristic(field) = 2 then
             gapForm := InvariantQuadraticForm(Omega(-1, d, q)).matrix;
         else
             gapForm := InvariantBilinearForm(Omega(-1, d, q)).matrix;
         fi;
     fi;
 
     if type in ["O", "O+", "O-"] then
-        if Characteristic(F) = 2 then
+        if Characteristic(field) = 2 then
             broadType := "O-Q";
         else
             broadType := "O-B";
@@ -182,7 +167,7 @@ function(group, type)
         broadType := type;
     fi;
 
-    return ConjugateToSesquilinearForm(group, broadType, gapForm);
+    return ConjugateToSesquilinearForm(group, broadType, gapForm, field);
 end);
 
 # Let <forms> = [f1, f2, ..., ft] be a list of sesquilinear forms on the vector
@@ -287,20 +272,15 @@ end);
 # In general, this function should only be used if one can be sure that <G>
 # preserves a unitary form (but one does not know which one). 
 InstallGlobalFunction("UnitaryForm",
-function(G)
-    local d, F, q, M, inverseHermitianConjugateM, formMatrix, row, col, x,
+function(G, F)
+    local d, q, M, inverseHermitianConjugateM, formMatrix, row, col, x,
     scalar, counter;
 
     d := DimensionOfMatrixGroup(G);
-    F := DefaultFieldOfMatrixGroup(G);
     if not IsFinite(F) then
         ErrorNoReturn("The base field of <G> must be finite");
     fi;
     if not IsEvenInt(DegreeOverPrimeField(F)) then
-        # It might be that G is to be understood as a matrix group over 
-        # GF(q ^ 2), but the matrices can actually be represented over a
-        # smaller field, which causes DefaultFieldOfMatrixGroup to return GF(q)
-        # instead of GF(q ^ 2) - we have to remedy this somehow ...
         q := Size(F);
     else
         q := RootInt(Size(F));
@@ -388,8 +368,8 @@ end);
 # In general, this function should only be used if one can be sure that <G>
 # preserves a bilinear form (but one does not know which one).
 InstallGlobalFunction("BilinearForm",
-function(G, type)
-    local F, M, inverseTransposeM, counter, formMatrix, condition;
+function(G, type, F)
+    local M, inverseTransposeM, counter, formMatrix, condition;
 
     if not type in ["S", "O"] then
         ErrorNoReturn("<type> must be one of 'S', 'O'");
@@ -402,8 +382,6 @@ function(G, type)
         condition := x -> (x = TransposedMat(x));
     fi;
 
-    F := DefaultFieldOfMatrixGroup(G);
-
     # Return stored bilinear form if it exists and is symplectic / symmetric
     if HasInvariantBilinearForm(G) then
         formMatrix := InvariantBilinearForm(G).matrix;
@@ -455,22 +433,21 @@ function(G, type)
 end);
 
 InstallGlobalFunction("SymplecticForm",
-function(G)
-    return BilinearForm(G, "S");
+function(G, F)
+    return BilinearForm(G, "S", F);
 end);
 
 InstallGlobalFunction("SymmetricBilinearForm",
-function(G)
-    return BilinearForm(G, "O");
+function(G, F)
+    return BilinearForm(G, "O", F);
 end);
 
 InstallGlobalFunction("QuadraticForm",
-function(G)
-    local d, F, formMatrix, polarFormMatrix, i, g, RightSideForLinSys,
+function(G, F)
+    local d, formMatrix, polarFormMatrix, i, g, RightSideForLinSys,
     MatrixForLinSys, x;
 
     d := DimensionOfMatrixGroup(G);
-    F := DefaultFieldOfMatrixGroup(G);
     if not IsFinite(F) then
         ErrorNoReturn("The base field of <G> must be finite");
     fi;
@@ -482,7 +459,7 @@ function(G)
 
     # We first look for an invariant symmetric bilinear form of G, which will
     # be the polar form of the desired quadratic form
-    polarFormMatrix := SymmetricBilinearForm(G);
+    polarFormMatrix := SymmetricBilinearForm(G, F);
     # The Gram matrix formMatrix of the quadratic form is upper triangular and
     # polarFormMatrix = formMatrix + formMatrix ^ T, so the entries above the
     # main diagonal of polarFormMatrix and formMatrix must be the same

gap/ImprimitiveMatrixGroups.gi

@@ -59,7 +59,7 @@ function(d, q, t)
     # We have to exclude m = 1 since the Forms package has a bug in this case;
     # however, this case is trivial.
     if m > 1 then
-        SUChangedForm := ConjugateToSesquilinearForm(SU(m, q), "U", IdentityMat(m, F));
+        SUChangedForm := ConjugateToSesquilinearForm(SU(m, q), "U", IdentityMat(m, F), F);
     else
         SUChangedForm := SU(m, q);
     fi;
@@ -108,7 +108,7 @@ function(d, q, t)
     # change back fixed form into standard GAP form Antidiag(1, ..., 1)
     SetInvariantSesquilinearForm(result, rec(matrix := IdentityMat(d, F)));
 
-    return ConjugateToStandardForm(result, "U");
+    return ConjugateToStandardForm(result, "U", F);
 end);
 
 # Construction as in Proposition 5.5 of [HR05]
@@ -170,7 +170,7 @@ function(d, q)
     result := MatrixGroupWithSize(F, generators, size);
     SetInvariantSesquilinearForm(result, rec(matrix := AntidiagonalMat(d, F)));
 
-    return ConjugateToStandardForm(result, "U");
+    return ConjugateToStandardForm(result, "U", F);
 end);
 
 # Construction as in Proposition 5.2 of [HR05]
@@ -268,7 +268,7 @@ function(d, q, t)
     result := MatrixGroupWithSize(field, gens, SizeSp(m, q) ^ t * Factorial(t));
     SetInvariantBilinearForm(result, rec(matrix := AntidiagonalHalfOneMat(d, field)));
 
-    return ConjugateToStandardForm(result, "S");
+    return ConjugateToStandardForm(result, "S", field);
 end);
 
 # Construction as in Proposition 5.3 of [HR05]
@@ -316,7 +316,7 @@ function(d, q)
     result := MatrixGroupWithSize(field, gens, SizeGL(l, q) * 2);
     SetInvariantBilinearForm(result, rec(matrix := AntidiagonalHalfOneMat(d, field)));
 
-    return ConjugateToStandardForm(result, "S");
+    return ConjugateToStandardForm(result, "S", field);
 end);
 
 # Construction as in Lemmata 5.2 and 5.3 of [HR10]
@@ -488,11 +488,11 @@ function(epsilon, d, q, epsilon_0, t)
     SetInvariantQuadraticFormFromMatrix(result, Q);
 
     if epsilon = -1 then
-        return ConjugateToStandardForm(result, "O-");
+        return ConjugateToStandardForm(result, "O-", field);
     elif epsilon = 0 then
-        return ConjugateToStandardForm(result, "O");
+        return ConjugateToStandardForm(result, "O", field);
     else
-        return ConjugateToStandardForm(result, "O+");
+        return ConjugateToStandardForm(result, "O+", field);
     fi;
 end);
 
@@ -530,7 +530,7 @@ function(d, q)
 
     result := MatrixGroupWithSize(field, gens, size);
     SetInvariantQuadraticFormFromMatrix(result, StandardOrthogonalForm(1, d, q).Q);
-    return ConjugateToStandardForm(result, "O+");
+    return ConjugateToStandardForm(result, "O+", field);
 end);
 
 # Construction as in Lemma 5.4 [HR10]
@@ -591,8 +591,8 @@ function(epsilon, d, q)
     SetInvariantQuadraticFormFromMatrix(result, Q);
 
     if epsilon = 1 then
-        return ConjugateToStandardForm(result, "O+");
+        return ConjugateToStandardForm(result, "O+", field);
     else
-        return ConjugateToStandardForm(result, "O-");
+        return ConjugateToStandardForm(result, "O-", field);
     fi;
 end);