test 277 with precomputed fields and galois groups

Grp.m

-intrinsic OuterAutomorphismRepresentatives(G :: Grp) -> []
-  { representatives for Out(G)/Inn(G) }
-  aut := AutomorphismGroup(G);
-  // m1 : autfp -> aut
-  autfp, m1 := FPGroup(aut);
-  // m2 : autfp -> outfp
-  outfp, m2 := OuterFPGroup(aut);
-  // m3 : outfp -> out
-  out, m3 := PermutationGroup(outfp);
-
-  return [g @@ m3 @@ m2 @ m1 : g in out];
-end intrinsic;
-
-intrinsic OuterAutomorphismGenerators(G :: Grp) -> []
-  { generators for Out(G)/Inn(G) }
-  aut := AutomorphismGroup(G);
-  // m1 : autfp -> aut
-  autfp, m1 := FPGroup(aut);
-  // m2 : autfp -> outfp
-  outfp, m2 := OuterFPGroup(aut);
-
-  return [g @@ m2 @ m1 : g in Generators(outfp)];
-end intrinsic;
-
-intrinsic IsIsomorphicPerm(G :: GrpPerm, H :: GrpPerm) -> BoolElt, Map
-  { Assuming G, H have the same degree, return an isomorphism which
-    preserves the cycle decomposition, if such isomorphism exists }
-
-    n := Degree(G);
-    if Degree(H) ne n then
-        return false;
-    end if;
-
-    b, x := IsConjugate(Sym(n), G, H);
-
-    if not b then
-        return false;
-    end if;
-
-    gens := OrderedGenerators(G);
-    isom := Isomorphism(G, H, gens, [x^-1*g*x : g in gens]);
-
-    return true, isom;
-end intrinsic;
-

Modularity.m

@@ -2,13 +2,10 @@
 // Proving modularity
 ///////////////////////
 
-Attach("GrpExt.m");
-Attach("Grp.m");
-
 declare type Modularity;
 
 declare attributes Modularity :
-  R1, discR1, frobR1, gal, rho, VGs, VHs, Vs, auts;
+  R1, discR1, frobR1, gal, rho, SG, VGs, VHs, Vs, auts;
 
 // ASSUME
 //   i. rho : Gal(R1) -~-> G, a subgroup inside Sp(4,2)
@@ -48,6 +45,7 @@ intrinsic ModNew (R1 :: FldNum, rho :: Map) -> Modularity
   m`frobR1 := frobR1;
   m`gal := gal;
   m`rho := rho;
+  m`SG := SG;
   m`VGs := VGs;
   m`VHs := VHs;
   m`Vs := Vs;

ex-277.m

-// Galois theory for C277
-
-ZZ := IntegerRing();
-ZZx<x> := PolynomialRing(ZZ);
-
-//f10 := x^10 + 6*x^9 + 15*x^8 + 22*x^7 + 24*x^6 + 12*x^5 - 18*x^4 - 34*x^3 - 9*x^2 + 2*x - 1;
-
-f10 := x^10 + 3*x^9 + x^8 - 10*x^7 - 17*x^6 - 7*x^5 + 11*x^4 + 18*x^3 + 13*x^2 + 5*x + 1;
-
-R1 := NumberField(f10);
-
-P2 := Radical(2*Integers(R1));
-S0 := Radical(277*Integers(R1));
-S11 := P2^11 * S0;
-
-gal, r, s := GaloisGroup(f10);
-
-// all the quadratic extensions ramified at (S, inf)
-function quad_ext(S, inf)
-  ray, m := RayClassGroup(S, inf);
-  return
-  [ AbelianExtension(Inverse(mq)*m)
-    where _, mq is quo<ray | Q>
-    where Q is QQ`subgroup
-  : QQ in Subgroups(ray : Quot:=[2])];
-end function;
-
-qexts := quad_ext(S11, [1..#RealPlaces(R1)]);
-
-//load "modularity.m";
-//load "mod-S5b.m";
-
-// m : gal -> G
-_, rho := IsIsomorphic(gal, G1);
-assert rho eq rho;
-
-
-

lib/Grp.m

+//////////////////////////////////////////////////
+//
+// Some useful group functions
+//
+// Author: Gonzalo Tornaría <tornaria@cmat.edu.uy>
+//
+//////////////////////////////////////////////////
+
+/********************************************************************/
+
+// Outer automorphisms
+
+intrinsic OuterAutomorphismRepresentatives(G :: Grp) -> {}
+  { A set of representatives for Aut(G)/Inner(G) }
+  return OuterAutomorphismRepresentatives(G, G);
+end intrinsic;
+
+intrinsic OuterAutomorphismRepresentatives(G :: GrpAb, H :: GrpAb) -> {}
+  { A set of representatives for Aut(H)/Inner(G) where H subset G }
+  error if not H subset G, "H must be a subset of G";
+  aut := AutomorphismGroup(H);
+  m, P := PermutationRepresentation(aut); // m : aut -> P
+  return P @ Set @@ m;
+end intrinsic;
+
+intrinsic OuterAutomorphismRepresentatives(G :: Grp, H :: Grp) -> {}
+  { A set of representatives for Aut(H)/Inner(G) where H subset G }
+  error if not H subset G, "H must be a subset of G";
+  aut := AutomorphismGroup(H);
+  m, P, Y := PermutationRepresentation(aut); // m : aut -> P
+  N := Normalizer(G, H);
+  inners := [ [Position(Y, g^-1*y*g) : y in Y] : g in Generators(N)];
+  inn := sub<P | inners>;
+  return Transversal(P, inn) @@ m @ Set;
+end intrinsic;
+
+intrinsic OuterAutomorphismGroup(G :: GrpAb) -> GrpPerm, Map
+  { A group O isomorphic to Aut(G)/Inner(G), and the epimorphism Aut(G)->O }
+  aut := AutomorphismGroup(G);
+  m, P := PermutationRepresentation(aut); // m : aut -> P
+  return P, m;
+end intrinsic;
+
+intrinsic OuterAutomorphismGroup(G :: Grp) -> GrpPerm, Map
+  { A group O isomorphic to Aut(G)/Inner(G), and the epimorphism Aut(G)->O }
+  aut := AutomorphismGroup(G);
+  m, P, Y := PermutationRepresentation(aut); // m : aut -> P
+  inners := [ [Position(Y, g^-1*y*g) : y in Y] : g in Generators(G)];
+  out, proy := quo<P | inners>;
+  return out, m * proy;
+end intrinsic;
+
+intrinsic OuterAutomorphismGenerators(G :: Grp) -> {}
+  { A set of generators for Aut(G)/Inner(G) }
+  out, m := OuterAutomorphismGroup(G);
+  return Generators(out) @@ m;
+end intrinsic;
+
+/********************************************************************/
+
+intrinsic MonomorphismRepresentatives(g :: GrpAb, G :: Grp) -> {}
+  { A set representatives for monomorphisms g --> G modulo Inner(G) }
+  p, m := PermutationGroup(g); // m : p -> g
+  phis := MonomorphismRepresentatives(p, G);
+  return { m^-1 * phi : phi in phis };
+end intrinsic;
+
+intrinsic MonomorphismRepresentatives(g :: Grp, G :: GrpAb) -> {}
+  { A set representatives for monomorphisms g --> G modulo Inner(G) }
+  // could be improved since Inner(G) is trivial
+  P, m := PermutationGroup(G); // m : P -> G
+  phis := MonomorphismRepresentatives(g, P);
+  return { phi * m : phi in phis };
+end intrinsic;
+
+intrinsic MonomorphismRepresentatives(g :: Grp, G :: Grp) -> {}
+  { A set representatives for monomorphisms g --> G modulo Inner(G) }
+
+  return &join [
+    { rho*psi*inc : psi in OuterAutomorphismRepresentatives(G, H`subgroup) }
+      where inc is Coercion(H`subgroup, G)
+    : H in Subgroups(G : OrderEqual := #g)
+    | b where b, rho is IsIsomorphic(g, H`subgroup)
+  ];
+
+end intrinsic
+
+declare type _GrpMonoData;
+declare attributes _GrpMonoData : G;
+
+/********************************************************************/
+
+intrinsic IsIsomorphicPerm(G :: GrpPerm, H :: GrpPerm) -> BoolElt, Map
+  { Assuming G, H have the same degree, return an isomorphism which
+    preserves the cycle decomposition, if such isomorphism exists }
+
+    n := Degree(G);
+    if Degree(H) ne n then
+        return false;
+    end if;
+
+    b, x := IsConjugate(Sym(n), G, H);
+
+    if not b then
+        return false;
+    end if;
+
+    gens := OrderedGenerators(G);
+    isom := Isomorphism(G, H, gens, [x^-1*g*x : g in gens]);
+
+    return true, isom;
+end intrinsic;
+
+/********************************************************************/
+
+intrinsic IsCorefree(G::Grp, H::Grp) -> BoolElt
+  { True if H is core-free in G }
+  return IsTrivial(Core(G, H));
+end intrinsic;
+
+intrinsic CorefreeSubgroups(G::Grp) -> []
+  { Core-free subgroups of G }
+  return [ H`subgroup
+         : H in Subgroups(G)
+         | IsCorefree(G, H`subgroup) ];
+end intrinsic;
+
+/********************************************************************/

lib/lib.spec

 {
   Frob.m
+  Grp.m
 }

mod.spec

@@ -3,5 +3,4 @@
 
   Modularity.m
   GrpExt.m
-  Grp.m
 }

run-277.m

-t0 := Cputime();
+ZZ := IntegerRing();
+ZZx<x> := PolynomialRing(ZZ);
 
-AttachSpec("mod.spec");
+/// DATA for C277
+load "../Brumer_S5/TR20n";
+load "../Brumer_S5/test277Gal20";
 
-load "ex.m";
-load "ex-277.m";
+K0 := NumberField(CAND277_10[1,3]);
+residual_traces := [<5,1>];
 
-m := ModNew(R1, rho);
-PS := Multiset([]);
-time for i := 1 to #qexts do
-  t := Cputime();
-  R2:=NumberField(qexts[i]);
-  proj, phis := ModPhis(m, R2);
-  dim := Integers() ! Log(2, #Domain(phis[1])/#G1);
-  ps := [ModPrimes(m, R2, proj, phi) : phi in phis];
-  for p in ps do 
-      Include(~PS, p);
-  end for;
-  printf "%4o: dim =%2o, %-40o  %o s\n", i, dim, Sort(ps), Cputime(t);
+num_fields := #CAND277_10[2];
+fields := func<i | NumberField(CAND277_10[2,i])>;
+gals := func<i | TR20n[CAND277_10[3,i]]>;
 
-  if i mod 10 eq 0 then
-      printf "\n%o\n\n", PS;
-      printf "    time: %o s  (avg %o s)\n\n", Cputime(t0), Cputime(t0)/i;
-  end if;
-
-end for;
-
-printf "\n\nFINAL: %o\n\n", PS;
-printf "Total time: %o s  (avg %o s)\n\n", Cputime(t0), Cputime(t0)/#qexts;
+load "run-test.m";

run-test.m

+//load "run-test.m";
+// Run modularity test for arbitrary residual representation
+// Expects the following to be defined before loading this file:
+//
+// K0 - field for the residual representation
+
+// residual_traces - a list of pairs <p,ap> such that
+// together with K0 determine the residual representation
+//
+// num_fields - the number of fields L0 given
+//
+// fields(i) - the field L0 for i in [1..num_fields]
+// gals(i) - the galois group of L0 for i in [1..num_fields]
+
+AttachSpec("mod.spec");
+
+t0 := Cputime();
+
+gal, r, s := GaloisGroup(K0);
+assert GaloisProof(K0, s);
+
+//// FIND the correct rho : gal --> Sp(4, 2)
+rhos := MonomorphismRepresentatives(gal, Sp(4,2));
+cc := [c[3] : c in ConjugacyClasses(gal)];
+for p_ap in residual_traces do
+  p, ap := Explode(p_ap);
+  frob := FrobeniusStructure(K0, p);
+  cc_frob := [c : c in cc | CycleStructure(c) eq frob];
+  rhos := [ rho : rho in rhos
+          | &or [Trace(rho(c)) eq ap : c in cc_frob] ];
+end for;
+
+assert #rhos eq 1;
+rho := rhos[1];
+
+assert IsConjugate(Sp(4,2), Image(rho), G1);
+
+tr := func<g | g[1,5]+g[2,6]+g[3,7]+g[4,8]>;
+tr1 := func<g | g[1,1]+g[2,2]+g[3,3]+g[4,4]>;
+
+m := ModNew(K0, rho);
+PS := Multiset([]);
+//time for i in [1..10] cat [1562] do
+time for i := 1 to num_fields do
+  t := Cputime();
+  R2 :=fields(i);
+  gal2 := gals(i);
+  //assert IsConjugate(S20, gal2, GaloisGroup(R2));
+  cc2 := [c[3] : c in ConjugacyClasses(gal2)];
+
+  ///// ModPhis
+  phis := [* *];
+  for VG in m`VGs do
+    b, phi := IsIsomorphic(gal2, VG`self);
+    if b then
+      //print "dim:", Dimension(VG);
+      for psi in m`auts[VG] do
+        Append(~phis, phi*psi);
+      end for;
+    end if;
+  end for;
+  /////
+
+
+  dim := Integers() ! Log(2, #Domain(phis[1])/#G1);
+
+  ps := [];
+  for phi in phis do
+    ///// check phi gives the correct traces
+    for p_ap in residual_traces do
+      p, ap := Explode(p_ap);
+      frob2 := FrobeniusStructure(R2, p);
+      cc2_frob := [c : c in cc2 | CycleStructure(c) eq frob2];
+      if &and [tr1(phi(c)) ne ap : c in cc2_frob] then
+        Append(~ps, -p);
+        continue phi;
+      end if;
+    end for;
+    if &and [ tr(phi(x)) eq 0 : x in cc2 ] then
+      Append(~ps, 1);
+      continue phi;
+    end if;
+    /////
+    fc := AssociativeArray();
+    for c2 in cc2 do
+      c1 := c2 @ phi @ m`SG`pi @@ rho;
+      pat := <CycleStructure(c1), CycleStructure(c2)>;
+      if not IsDefined(fc, pat) then
+        fc[pat] := [ c2 ];
+      else
+        Append(~fc[pat], c2);
+      end if;
+    end for;
+    for p in PrimesUpTo(200) do
+      if m`discR1 mod p eq 0 then
+        continue;
+      end if;
+      pat := <m`frobR1[p], FrobeniusStructure(R2, p)>;
+      all_classes := fc[pat];
+      bad_classes := [ c : c in all_classes | tr(phi(c)) eq 0 ];
+      if bad_classes eq [] then
+        Append(~ps, p);
+        continue phi;
+      end if;
+    end for;
+    // Bad cocycle
+    Append(~ps, 0);
+  end for;
+
+  //ps := [ModPrimes(m, R2, proj, phi) : phi in phis];
+  for p in ps do 
+      Include(~PS, p);
+  end for;
+  printf "%4o: dim =%2o, %-40o  %o s\n", i, dim, Sort(ps), Cputime(t);
+
+  if i mod 10 eq 0 then
+      printf "\n%o\n\n", PS;
+      printf "    time: %o s  (avg %o s)\n\n", Cputime(t0), Cputime(t0)/i;
+  end if;
+
+end for;
+
+printf "\n\nFINAL: %o\n\n", PS;
+printf "Total time: %o s  (avg %o s)\n\n", Cputime(t0),
+       Cputime(t0)/num_fields;