Magma V2.20-8     Mon Oct  6 2014 15:49:50 on mathcompprd01 [Seed = 2714012174]
Type ? for help.  Type <Ctrl>-D to quit.

Loading startup file "/home/eobr007/.magma.startup"

> load "code.m";
Loading "code.m"
> // SetVerbose ("Classes", 1);
> // SetVerbose ("RandomSchreier", 1);
> // load "z.m";
> // SetEchoInput (true);
> 
> // is vector space large enough?
> CanHaveRegularOrbit := function (G)
>    d := Degree (G);
>    F := BaseRing (G);
>    V := VectorSpace (F, d);
>    o := #G;
>    if #V lt #G then "Vector space too small -- no regular orbit";
>       return false, true; 
>    else
>       return true, true;
>    end if;
> end function;
> 
> // determine if G has regular orbit by covering vector space 
> HasRegularOrbit := function (G: Limit := 1000)
>    d := Degree (G);
>    F := BaseRing (G);
>    V := VectorSpace (F, d);
>    o := #G;
>    if #V lt #G then "Vector space too small -- no regular orbit";
>       return false, true; 
>    end if;
> 
>    O := {};
>    nmr := 0;
>    "Order of G is ", #G;
>    repeat
>       repeat 
>          v := Random (V);
>       until not (v in O);
>       o := Orbit (G, v);
>       if #o eq #G then "Found regular orbit"; return true, true; end if;
>       O join:= o;
>       "... #O is now ", #O;
>       nmr +:= 1;
>       decided := #V - #O lt #G;
>    until decided or nmr gt Limit;
>    if decided then 
>       "Proved no regular orbit"; return false, true; 
>    end if;
>    if nmr gt Limit then 
>       "Could not decide about regular orbit"; return false, false; 
>    end if;
> end function;
> 
> /* find space centralised by g */
> CentralisedSpace := function (g)
>    G := Parent (g);
>    F := CoefficientRing (G);
>    A := MatrixAlgebra (F, Degree (G));
>    a := A!g;
>    N := NullSpace (a - Identity (A));
>    // "Nullspace has dimension ", Dimension (N);
>    return N;
> end function;
> 
> RefinedBound := function (G, n)
>    C := LMGClasses (G);
>    order := #G;
>    index := [i : i in [1..#C] | IsPrime (C[i][1]) and order mod C[i][1] eq 0];
>    reps := [C[i][3]: i in index];
>    sizes := [C[i][2]: i in index];
>    spaces := [#CentralisedSpace (reps[i]) : i in [1..#reps]];
>    size := &+[sizes[i] * spaces[i]: i in [1..#spaces]];
>    p := Characteristic (BaseRing (G));
>    e := Ilog (p, size);
>    assert p^(e + 1) ge size;
>    if p^e eq size then return e; else return e + 1; end if;
> end function;
> 
> Scalars := function (d, q)
>    F := GF (q);
>    nu := PrimitiveElement (F);
>    M := MatrixAlgebra (F, d);
>    s := ScalarMatrix (M, nu);
>    return sub<GL(d, F) | s>;
> end function;
> 
> // H defined over GF(q); construct G = H \circ scalars of F_q 
> AddScalar := function (H)
>    F := BaseRing (H);
>    if #F gt 2 then 
>       S := Scalars (Degree (H), #F);
>       G := sub<Generic (H) | H, S.1>; 
>       return G;
>    else 
>       return H;
>    end if;
> end function;
> 
> // L list of reps; n degree; Scalar: add scalar 
> // decide if rep has regular orbit
> ProcessReps := function (L, n: Scalar := true)
>    for i in [1..#L] do
>        "Consider the following repn", i; 
>        H := L[i];
>        G := Scalar select AddScalar (H) else H;
> 
>        F := BaseRing (G);
>        p := Characteristic (F);
> 
>        "Input degree = ", Degree (G), " Defining field size = ", #F;
>    
>        // replace by absolute representation
>        if not IsPrime (#F) and not IsAbsolutelyIrreducible (G) then 
>           G := AbsoluteRepresentation (G);
>           "Replaced G by its absolute representation";
>           "New degree = ", Degree (G), "New field size = ", #F;
>        end if;
> 
>        // is G conjugate to group defined over smaller field? 
>        flag, H := IsOverSmallerField (G);
>        if flag then 
>           G := H; 
>           "Conjugated G to smaller field";
>           "Degree = ", Degree (G), "New field size = ", #F;
>        end if;
> 
>        if not IsPrime (#F) then
>           G := WriteOverSmallerField (G, GF(p));
>           "Rewrite G over prime field -- now degree = ", Degree (G);
>        end if;
> 
>        o := LMGOrder (G);
>        "Composition Factors of G is "; 
>        LMGCompositionFactors (G);
> 
>        if CanHaveRegularOrbit (G) then 
>           e := RefinedBound (G, n); 
>           "Refined bound on degree is ", e;
>           if Degree (G) gt e then 
>              "Over refined degree limit -- so G has regular orbit";
>              regular := true;
>           else
>              regular := HasRegularOrbit (G);
>              // "Has regular orbit?", regular;
>           end if;
>        end if;
>        "========================================";
>    end for;
>    return true;
> end function;
> 
> n := 16;
> G := Sym (n);
> RandomSchreier (G);
> order := #G;
> Dims := [[128, 336]];
> Primes := [2];
> 
> for i in [1..#Primes] do 
for>    p := Primes[i]; dims := Dims[i];
for>    "\n\nProcess n = ", n, "p = ", p;
for>    I := IrreducibleModules (G, GF (p): MaxDegree := Maximum (dims));
for>    J := [x : x in I | Dimension (x) in dims];
for>    L := [ActionGroup (j): j in J];
for>    O := [LMGOrder (l): l in L];
for>    L := [L[i]: i in [1..#L] | O[i] eq #G];
for>    "Faithful reps over GF(", p, ") have dimensions:", [Degree (l): l in L],
"\n";
for>    f := ProcessReps (L, n);
for> end for;


Process n =  16 p =  2
 *** ERROR -- not all irreducible modules found.
Faithful reps over GF( 2 ) have dimensions: [ 128, 336 ]


Consider the following repn 1
Input degree =  128  Defining field size =  2
Composition Factors of G is 
    G
    |  Cyclic(2)
    *
    |  Alternating(16)
    1
#Warning: we will need to find a perm rep of the radical quotient!
#Found perm rep of the radical quotient!
Refined bound on degree is  94
Over refined degree limit -- so G has regular orbit
========================================
Consider the following repn 2
Input degree =  336  Defining field size =  2
Composition Factors of G is 
    G
    |  Cyclic(2)
    *
    |  Alternating(16)
    1
#Warning: we will need to find a perm rep of the radical quotient!
#Found perm rep of the radical quotient!
Refined bound on degree is  279
Over refined degree limit -- so G has regular orbit
========================================

Total time: 3893.109 seconds, Total memory usage: 2579.34MB