Commit a9e51c58 by Gonzalo Tornaría

### test 277 with precomputed fields and galois groups

parent c3f24dba
Grp.m deleted 100644 → 0
 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; ... ...
ex-277.m deleted 100644 → 0
 // Galois theory for C277 ZZ := IntegerRing(); ZZx := 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 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 0 → 100644
 ////////////////////////////////////////////////// // // Some useful group functions // // Author: Gonzalo Tornaría // ////////////////////////////////////////////////// /********************************************************************/ // 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

; 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

; 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; /********************************************************************/

 { Frob.m Grp.m }
 ... ... @@ -3,5 +3,4 @@ Modularity.m GrpExt.m Grp.m }
 t0 := Cputime(); ZZ := IntegerRing(); ZZx := 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; gals := func; 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 0 → 100644
 //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 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; tr1 := func; 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 := ; 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 := ; 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!