Magma V2.20-8 Mon Oct 6 2014 17:48:09 on mathcompprd01 [Seed = 574633545] Type ? for help. Type -D to quit. Loading startup file "/home/eobr007/.magma.startup" Loading "s20-d512-f2" Loading "z.m" > 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; > 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; > 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 := 20; > L := [G]; > p := 2; > "\n\nProcess n = ", n, "p = ", p; Process n = 20 p = 2 > "Faithful reps over GF(", p, ") have dimensions:", [Degree (l): l in L], "\n"; Faithful reps over GF( 2 ) have dimensions: [ 512 ] > f := ProcessReps (L, n); Consider the following repn 1 Input degree = 512 Defining field size = 2 Composition Factors of G is G | Cyclic(2) * | Alternating(20) 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 302 Over refined degree limit -- so G has regular orbit ======================================== Total time: 681.730 seconds, Total memory usage: 8143.25MB