Commit a9e51c58 authored by Gonzalo Tornaria's avatar Gonzalo Tornaria

test 277 with precomputed fields and galois groups

parent c3f24dba
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;
......@@ -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;
......
// 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;
//////////////////////////////////////////////////
//
// 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;
/********************************************************************/
......@@ -3,5 +3,4 @@
Modularity.m
GrpExt.m
Grp.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";
//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;
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment