Magma V2.20-8 Thu Oct 9 2014 20:39:47 on mathcompprd07 [Seed = 208561062] Type ? for help. Type -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; > 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? > if not IsPrime (#F) then > flag, H := IsOverSmallerField (G); > if flag then > G := H; > "Conjugated G to smaller field"; > "Degree = ", Degree (G), "New field size = ", #F; > end if; > 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 := 6; > G := Alt (n); > p := 5; > J := IrreducibleModules (G, GF (p)); > J := [j :j in J | Dimension (j) eq 5]; > s := ScalarMatrix (5, GF(5)!-1); > J := [ActionGroup (j): j in J]; > [#j: j in J]; [ 360, 360 ] > L := [sub: i in [1..2]]; > ProcessReps (L, 6: Scalar:= false); Consider the following repn 1 Input degree = 5 Defining field size = 5 Composition Factors of G is G | Alternating(6) * | Cyclic(2) 1 Refined bound on degree is 6 Order of G is 720 ... #O is now 120 ... #O is now 480 ... #O is now 840 ... #O is now 1080 ... #O is now 1140 ... #O is now 1260 ... #O is now 1380 ... #O is now 1560 ... #O is now 1920 ... #O is now 2040 ... #O is now 2280 ... #O is now 2460 Proved no regular orbit ======================================== Consider the following repn 2 Input degree = 5 Defining field size = 5 Composition Factors of G is G | Alternating(6) * | Cyclic(2) 1 Refined bound on degree is 6 Order of G is 720 ... #O is now 360 ... #O is now 480 ... #O is now 840 ... #O is now 960 ... #O is now 1080 ... #O is now 1110 ... #O is now 1200 ... #O is now 1230 ... #O is now 1470 ... #O is now 1590 ... #O is now 1650 ... #O is now 2010 ... #O is now 2040 ... #O is now 2220 ... #O is now 2232 ... #O is now 2252 ... #O is now 2432 Proved no regular orbit ======================================== true Total time: 0.900 seconds, Total memory usage: 32.09MB