added char 2 case for FilterFormspace (needs work for bilinear case?) Still needs tests; removed old debug comments

Author: GalaxyCo

lib/forms.gi

@@ -1731,7 +1731,8 @@ InstallMethod( FORMS_IsSymmetricMatrix, [IsFFECollColl],
     local n, i, j;
     n := NrRows(m);
     for i in [1..n] do
-      for j in [1..i] do
+      # minus one to ignore diagonal entries for symmetric matrices.
+      for j in [1..i - 1] do
         if m[i, j] <> m[j, i] then
           return false;
         fi;

lib/formspace.gi

@@ -117,6 +117,17 @@ FORMS_MatrixReorganize := function(mat, j, F, n)
     return vec;
 end;
 
+# given j times n matrices over field F, this tries to compute a linear combination of the matrices such that their sum is zero.
+# todo maybe make this funciton more efficient by only considereing some equations, then considering more and so on until we are done.
+FORMS_SolveMatrixSystem := function(mats, j, n, F)
+    local eqs, mat, sol, out;
+    eqs := [];
+    for mat in mats do 
+        Add(eqs, FORMS_MatrixReorganize(mat, j, F, n));
+    od;
+    return NullspaceMatDestructive(eqs);
+end;
+
 # Spins the stuff
 FORMS_FrobSpin := function(Images, spin_elem, frob_base_blocks, n, F)
     local A, j, i, k, end_pos;
@@ -162,32 +173,22 @@ FORMS_ComputeConditionMatrixFrob := function(u, h, h_star, scalar_h, g_star_inv_
     local coeffs_c, coeffs_f, Ps, i, j, b_end, b_start, cpol, fpol;
     coeffs_c := (u * h) * frob_base_inv;
     coeffs_f := (u * frob_base_inv) * scalar_h;
-    # Display(coeffs_c);
     j := Size(frob_base[3]);
     Ps := NullMat(n * j, n, F);
     ConvertToMatrixRep(Ps, F);
-    # Print(frob_base[3], "\n");
     for i in [1..j] do
         if i = j then
             b_end := n;
         else
             b_end := frob_base[3][i + 1] - 1;
         fi;
-        # Print("[", ((i - 1)*n + 1), ",", (i*n), "\n");
-        #Print("->", frob_base[3][i],",",b_end, "\n");
+        # this code looks horrible .... :(
         Ps{[((i - 1)*n + 1)..(i*n)]}{[1..n]} :=
             FORMS_EvaluatePolynomialWithFrobenius(coeffs_c{[frob_base[3][i]..b_end]}, g_star_inv_scaled, frob_base, frob_base_inv_star, F, n) * h_star -  FORMS_EvaluatePolynomialWithFrobenius(coeffs_f{[frob_base[3][i]..b_end]}, g_star_inv_scaled, frob_base, frob_base_inv_star, F, n);
-        # cpol := UnivariatePolynomial(F, coeffs_c);
-        # fpol := UnivariatePolynomial(F, coeffs_f);
-        # Ps{[((i - 1)*n + 1)..(i*n)]}{[1..n]} :=
-        #     cpol(g_star_inv_scaled) * h_star - fpol(g_star_inv_scaled);
-        # Print(aua);
     od;
     return Ps;
 end;
 
-
-
 FORMS_FrobSpinAtBlock := function(Image, spin_elem, frob_base_blocks, block_index, n, F)
     local A, j, i, k, end_pos;
     j := Size(frob_base_blocks);
@@ -230,7 +231,7 @@ end;
 # find symplectic and symmetric matrices in Forms
 # returns bases [[symmetric forms], [symplectic forms]]
 FORMS_FilterBilinearForms := function(Forms, F, n)
-    local transposed_equal_result, form, symmetric_base, symplectic_base, transposed_form, TransposedEqual, symmetric_base_vecs, symplectic_base_vecs, char_2_eqs, sol, out, mat;
+    local transposed_equal_result, form, symmetric_base, symplectic_base, transposed_form, TransposedEqual, symmetric_base_vecs, symplectic_base_vecs, char_2_eqs, sol, out, mat, tmp, i, s;
 
     if Size(Forms) = 0 then
         return [];
@@ -257,7 +258,6 @@ FORMS_FilterBilinearForms := function(Forms, F, n)
             CloseMutableBasis(symplectic_base, form - transposed_form);
         od;
 
-
         symmetric_base_vecs := BasisVectors(ImmutableBasis(symmetric_base));
         symplectic_base_vecs := BasisVectors(ImmutableBasis(symplectic_base));
 
@@ -273,20 +273,23 @@ FORMS_FilterBilinearForms := function(Forms, F, n)
     ## TODO: this code is broken right now, FIX!! the issue seems to lie in the function FORMS_MatrixReorganize
     char_2_eqs := [];
     for form in Forms do
-        Add(char_2_eqs, FORMS_MatrixReorganize(form - TransposedMat(form), n, F, n));
+        Add(char_2_eqs, form - TransposedMat(form));
     od;
-    sol := NullspaceMatDestructive(char_2_eqs);
     out := [];
-    for form in sol do
-        Add(out, FORMS_VectorReorganize(form, n, F, n));
+    sol := FORMS_SolveMatrixSystem(char_2_eqs, n, n, F);
+    for s in sol do
+        tmp := Forms[1]*s[1];
+        for i in [2..Size(s)] do
+            tmp := tmp + s[i]*Forms[i];
+        od;
+        Add(out, tmp);
     od;
     return out;
 end;
 
-# tries to filter the F = GF(q^2) vectorspace generated by <Forms> and return the GF(q) vector space A such that A = <Forms> \cap B where B = {A \in F^{n\times n}, A* = A} TODO: THIS NEEDS SOME FURTHER INVESTIGATION
-# there must be a better way to compute these matrices..
+# tries to filter the F = GF(q^2) vectorspace generated by <Forms> and return the GF(q) vector space A such that A = <Forms> \cap B where B = {A \in F^{n\times n}, A* = A}
 FORMS_FilterUnitaryForms := function(Forms, F, n, hom)
-    local i, j, ent, q, half, O, l, FF, p, tr_form, Base, baseVecs, gf_base, hgf_base, mat;
+    local i, j, ent, q, half, O, l, FF, p, tr_form, Base, baseVecs, gf_base, hgf_base, mat, small_field, field_aut_mat, gf_base_vecs, big_aut_mat, to_smaller_field_matrix, transpose_weird_mat, apply_aut_to_mat, eqs, s, form, form_changed, sol, out, tmp, big_field, changed_forms, apply_coefficient_and_get_smaller_matrix, square_base_entry_rep, multiply_with_scalar, form_changed_mult, form_changed_mult_star, form_changed_star;
     if Size(Forms) = 0 then
         return [];
     fi;
@@ -296,59 +299,111 @@ FORMS_FilterUnitaryForms := function(Forms, F, n, hom)
     if Size(Forms) = 1 then
         #checks if A = A* or A = cA* if A = A* return A, if A = cA* we want to return scalar multiples of A, namely lA for l such that c = l^(1-q) iff c^-1 = l^(q-1)
         # all the solutions then are lA*GF(q) is this correct?? i am not sure if this are indeed all the possible solutions, but it certanly are solutions.
-        # Print(ff);
         l := FORMS_ScalarFormIdentifyCheck(Forms[1], F, n, hom, p, q);
         if l = fail then
             return [];
         fi;
 
         return [Forms[1] * l];
     fi;
-    # this is where it gets interesting
-    # Print("ahhh this needs work!\n");
-    # kind of okay case?
 
-    ## TODO proof if gAg^* = cA for some c it must hold that c \in GF(q) (not in GF(q^2))
+    ## If A = A* is a form preserved modulo scalar c in GF(q^2) i.e. gAg* = cA for group elements g. then c in GF(q).
 
-    ## we use (A + A*) is a hermitian form if gAg* = A the problem here is that for A, B such that gA*g = A and gB*g = B we may loose information namely it may be the case that 1/2 (A + A*) = c/2 (B + B*) this is annoying.... one thing one could do is check whether these matrices <1/2 (A + A*), 1/2 (B + B*), ...> are lineraly independent. if that is the case, we know that all forms must have been found (but do we???). but what if not? then there might be another form... this is annoying. Then we may add matrices A, B and so on such that <C1,C2, ., D1, D2..> is a basis of F where C1 and so on are hermitian and D1, D2 and so on are not. We may write D1 = A + B where A is hermitian and B is not. we can then try to write B in terms of the other matrices??? does this help... idk :(
-    ## for char = 2 this can be a bad idea as it can make the diagonal disaapear..   oh well
+    ## for char = 2 this can not yield all hermitian matrices as it deletes the diagonal disaapear.
     if p <> 2 then
         Base := MutableBasis(GF(q), [NullMat(n, n, GF(q))]);
         # Base := MutableBasis(GF(q), [], ZeroVector(GF(q), n));
         gf_base := BasisVectors(Basis(GF(GF(q), 2)))[2];
         hgf_base := hom(gf_base);
         for FF in Forms do
-            # l := FORMS_ScalarFormIdentifyCheck(FF, F, n, hom, p, q);
-            # if l = fail then
             tr_form := TransposedMat(FF^hom);
             CloseMutableBasis(Base, FF + tr_form);
             CloseMutableBasis(Base, gf_base * FF + hgf_base*tr_form);
-            # else
-                # CloseMutableBasis(Base, l * FF);
-            # fi;
         od;
 
         O := [];
         baseVecs := BasisVectors(ImmutableBasis(Base));
-        # for FF in baseVecs do
-        #     Add(O, HermitianFormByMatrix(FF, F));
-        # od;
-
-        # if Size(O) = Size(Forms) then
-        #     return O;
-        # fi;
-        # if Size(baseVecs) = Size(Forms) then
-        #     return baseVecs;
-        # fi;
-        # for mat in baseVecs do
-        #     ConvertToMatrixRep(mat, F);
-        # od;
+
         return baseVecs;
     fi;
-    Print("char 2 case is missing!!");
-    # # TODO this function definetly needs work!!!
-    # Print("Could not find a basis of hermitian Forms. Returned hermitian Forms and a Bigger space of matrices that contains all possible hermitian forms. \n");
-    # return [baseVecs, Forms];
+
+    # the idea for char 2 is to solve the semiliner system of equations. we take a F_q basis of F_q^2 namely <1, delta> and express n times n matrices with this basis. 
+
+    # TODO: this function is potentially really slow, it would be much better two only take a few equations and constain the problem instead of taking the entire n times n matrix. One such example would be the form space preserved by G := Group(SU(200, 2^2).1) then Size(Forms) = 38420 consisting of 200x200 matrices. 
+
+    small_field := GF(q);
+    big_field := GF(q^2);
+    gf_base := Basis(GF(small_field, 2));
+    gf_base_vecs :=  BasisVectors(gf_base);
+    # expresses n times n matrices as 2n times n matrices where 2 time 1 collumn vectors contain the coefficients ascoiciated with the basis gf_base
+    to_smaller_field_matrix := function(basis_of_field, small_field_, mat, n, c)
+        local outmat, i, j;
+        outmat := NullMat(2 * n, c, small_field_);
+        for i in [1..n] do
+            for j in [1..c] do
+                outmat{[(2*i - 1)..(2*i)]}[j] := Coefficients(basis_of_field, mat[i][j]);
+            od;
+        od;
+        ConvertToMatrixRep(outmat, small_field_);
+        return outmat;
+    end;
+    # this matrix applies the field automorphism hom to a element expressed in the basis over the smaller field
+    field_aut_mat := to_smaller_field_matrix(gf_base, small_field, [[hom(gf_base_vecs[1]), hom(gf_base_vecs[2])]], 1, 2); 
+    apply_aut_to_mat := function(mat, n, aut_mat)
+        local outmat, i, j;
+        outmat := 1*mat; # ugly hack to force gap to make a new copy of the matrix.
+        for i in [1..n] do
+            for j in [1..n] do
+                outmat{[(2*i - 1)..(2*i)]}[j] := aut_mat * outmat{[(2* i - 1)..(2*i)]}[j];
+            od;
+        od;
+        return outmat;
+    end;
+
+    # transposes 2n times n matrix  
+    transpose_weird_mat := function(mat, n)
+        local outmat, i, j;
+        outmat := 1*mat; # hack to force gap to copy the matrix.
+        for i in [1..n] do
+            for j in [1..n] do
+                outmat{[(2*i-1)..(2*i)]}[j] := mat{[(2*j-1)..(2*j)]}[i];
+            od;
+        od;
+        return outmat;
+    end;
+
+    square_base_entry_rep := Coefficients(gf_base, gf_base_vecs[2]^2);
+    # multiplies a 2n times n matrix over F_q with a scalar from F_q^2
+    multiply_with_scalar := function(scalar,gf_base, square_base_entry_rep, mat, n)
+        local smat, srep;
+        srep := Coefficients(gf_base, scalar);
+        smat := [[srep[1], srep[2] * square_base_entry_rep[1]], 
+        [srep[2], srep[1] + srep[2] * square_base_entry_rep[2]]];
+        return apply_aut_to_mat(mat, n, smat);
+    end;
+
+    eqs := [];
+    # build linear equations that can now be solved over F_q
+    for form in Forms do
+        form_changed := to_smaller_field_matrix(gf_base, small_field, form, n, n);
+        form_changed_star := apply_aut_to_mat(transpose_weird_mat(form_changed, n), n, field_aut_mat);
+        form_changed_mult := multiply_with_scalar(gf_base_vecs[2], gf_base, square_base_entry_rep, form_changed, n);
+        form_changed_mult_star := multiply_with_scalar(hom(gf_base_vecs[2]), gf_base, square_base_entry_rep, form_changed, n);
+
+        Add(eqs, form_changed - form_changed_star);
+        Add(eqs, form_changed_mult - form_changed_mult_star);
+    od;
+
+    sol := FORMS_SolveMatrixSystem(eqs, 2*n, n, small_field);
+    out := [];
+    for s in sol do
+        tmp := (s[1]*gf_base_vecs[1] + s[2]*gf_base_vecs[2])*Forms[1];
+        for i in [2..Size(Forms)] do
+            tmp := tmp + (s[2*i - 1]*gf_base_vecs[1] + s[2*i]*gf_base_vecs[2])*Forms[i];
+        od;
+        Add(out, tmp);
+    od;
+    return out;
 end;
 
 # Compute the formspace for cyclic matrix group. 
@@ -414,9 +469,9 @@ FORMS_FormspaceInternal := function(Gens, Lambdas, unitary, hom, g_res, g_inv_fr
                 fi;
                 W := nspace;
                 first := false;
-                # technically we still need checking here..
             fi;
             if Size(nspace) = 1 then
+                # technically we still need checking here..
                 needs_checking := true;
                 break;
             fi;
@@ -437,11 +492,6 @@ FORMS_FormspaceInternal := function(Gens, Lambdas, unitary, hom, g_res, g_inv_fr
             od;
             if not failed_check then
                 Add(O, A);
-                # if not unitary then
-                #     Add(O, BilinearFormByMatrix(A, F));
-                # else
-                #     Add(O, A);
-                # fi;
             fi;
         fi;
         if not needs_checking then
@@ -531,15 +581,13 @@ InstallMethod(PreservedFormspace,
         Out := [];
         F := DefaultFieldOfMatrixGroup(G);
         p_exponent := DegreeOverPrimeField(F);
-        # Prüfen ob es sich um einen endlichen körper handelt??
+        # Todo check if F finite?
         Gens := GeneratorsOfGroup(G);
-        # F := DefaultFieldOfMatrix(Gens[1]);
         n := NrRows(Gens[1]);
         d := Size(Gens);
         hom := fail;
 
         if d = 1 then
-            # Todo.... !!
             Gen := Gens[1];
             Gen_adjoint := FORMS_CalculateAdjoint(Gen, false, fail, n, F);
             Gen_adjoint_inv_scaled := One(F)*Inverse(Gen_adjoint); # scaling happens here!!